Question

public class NumStack implements Comparable{
private Integer[] data;
private int index;
public NumStack(int cap){
data=new Integer[cap];
index =-1;
}
public boolean isEmpty(){
return index == -1;
}
public boolean isFull(){
return index==data.length -1;
}
public NumStack pop(){
if(!isEmpty()) data[index--]=null;
return this;
}
public int size(){
return index+1;
}
public Integer top(){
if(isEmpty()) return null;
return data[index];
}
public NumStack push(int num){
if(index < data.length-1)
data[++index]=num;
return this;
}
public int compareTo(NumStack s){}
}

public int compareTo(NumStack s) compares two stack from the bottom of each stack, for example, s1[2,0, 9] and s2[9,0,9], calling s1.compareTo(s2) should return -1,
s1 s2
top 9 9 3rd: 9==9 we get 0
0 0 2nd: 0==0 we get 0
bottom 2 9 1st: 2<9 we get -1
------------------------------------------
add all and return: -1
If the two stacks have different sizes, then we consider the ith item is greater than the "none-existing item" in the smaller stack. For example, s1[8,0, -9] and s2[1], calling s1.compareTo(s2) should return 3,
s1 s2
top -9 3rd: no item in s1 ->1
0 2nd: no item in s2 ->1
bottom 8 1 1st: 8>1 ->1
-----------------------------------------
add all and return: 3

Answer 1

Here is the completed code for this problem. Also included a Test class to test compareTo method, ignore if you don’t need it. Comments are included, go through it, learn how things work and let me know if you have any doubts or if you need anything to change. If you are satisfied with the solution, please rate the answer. Thanks

// NumStack.java

public class NumStack implements Comparable<NumStack> {

      private Integer[] data;

      private int index;

      public NumStack(int cap) {

            data = new Integer[cap];

            index = -1;

      }

      public boolean isEmpty() {

            return index == -1;

      }

      public boolean isFull() {

            return index == data.length - 1;

      }

      public NumStack pop() {

            if (!isEmpty())

                  data[index--] = null;

            return this;

      }

      public int size() {

            return index + 1;

      }

      public Integer top() {

            if (isEmpty())

                  return null;

            return data[index];

      }

      public NumStack push(int num) {

            if (index < data.length - 1)

                  data[++index] = num;

            return this;

      }

      public int compareTo(NumStack s) {

            int n = 0;

            // finding the last index of bigger stack and assigning to n

            if (this.size() >= s.size()) {

                  n = this.size() - 1;

            } else {

                  n = s.size() - 1;

            }

            // initializing a variable to store sum of all comparison results

            int returnValue = 0;

            // looping as long as n is not negative

            while (n >= 0) {

                  // declaring two variables

                  int num1, num2;

                  // checking if n is a valid index on this stack

                  if (n >= this.size()) {

                       // not a valid index, assigning MIN_VALUE to num1 so that any

                       // number will possibly be greater than this 'non existant'

                       // number

                       num1 = Integer.MIN_VALUE;

                  } else {

                       // n is a valid index, fetching current value to num1

                       num1 = this.data[n];

                  }

                  // checking if n is a valid index on s stack

                  if (n >= s.size()) {

                       // not a valid index, assigning MIN_VALUE to num2 so that any

                       // number will possibly be greater than this 'non existant'

                       // number

                       num2 = Integer.MIN_VALUE;

                  } else {

                       // n is a valid index, fetching current value to num2

                       num2 = s.data[n];

                  }

                  // now actually comparing these two numbers

                  if (num1 < num2) {

                       // num1 comes before num2

                       returnValue += -1;

                  } else if (num1 > num2) {

                       // num2 comes before num1

                       returnValue += 1;

                  } // else we add 0, so it is not required

                  n--; // moving to previous index

            }

            return returnValue;

      }

}

// Test.java (ignore it if you don’t need it)

public class Test {

      public static void main(String[] args) {

            // creating two stacks

            NumStack stack1 = new NumStack(10);

            NumStack stack2 = new NumStack(10);

            // adding 2,0,9 to stack1

            stack1.push(2);

            stack1.push(0);

            stack1.push(9);

            // adding 9,0,9 to stack2

            stack2.push(9);

            stack2.push(0);

            stack2.push(9);

            // comparing stack1 and stack2, should display -1

            System.out.println(stack1.compareTo(stack2));

            // re initializing stacks

            stack1 = new NumStack(10);

            // pushing 8,0,9

            stack1.push(8);

            stack1.push(0);

            stack1.push(-9);

            stack2 = new NumStack(10);

            // pushing only 1

            stack2.push(1);

            // comparing stack[8,0,9] to stack[1] should display 3

            System.out.println(stack1.compareTo(stack2));

      }

}

/*OUTPUT*/

-1

3