Способ доступа к элементу верхнего стека для рекурсивного сравнения, если оба элемента стека одинаковы

Question

Как получить доступ к верхним элементам каждого стека, чтобы я мог их сравнить? Я использовал (iTop, i2Top, nTop, n2Top), потому что я тестировал, чтобы сделать эту работу, но я не могу получить правильный вывод. Что я делаю не так?

Я предполагал, что это сработает, но это не так. По сути, я хочу сослаться на верхний элемент стека и сравнить его с верхним элементом стека2. Затем, если они равны, вытолкните их и сделайте то же самое для остальной части стека. В конце, если стек пуст, потому что все элементы были одинаковыми и были вытолкнуты, то это правда, стеки одинаковы. И пу sh обратно стек 1 и стек 2. Спасибо

public Boolean sameStack(StackArray<E> s2) {
            E t1, t2;
            //E iTop = this.items[top];
            //E i2Top= s2.items[top];
            int nTop = this.top; // 
            int n2Top= s2.top;  // nTop == n2Top is true even when elements are not equal
            boolean t = true;

            if(this.isEmpty() && s2.isEmpty()) {
                return t;
            }//if
            if(this.top != s2.top) {
                t = false;
                return t;
            }   
            if(this.items[top] == s2.items[s2.top]){
                t1 = this.pop();
                t2 = s2.pop();
                t = sameStack(s2);
                push(t1);
                push(t2);
            }
            else{
                t = false;
            }
            return t;
}

public class StackArray<E> {

        private int top=-1;
        private static final int MAX_ITEMS = 10;
        private E items[];

        @SuppressWarnings("unchecked")
        public StackArray() {
            items = (E[]) new Object[MAX_ITEMS];
            System.out.println("Stack Created!");
        }

        public void push(E e) {
            if (isFull()==true) {
            System.out.println("Stack Full!");
            }
            else{
                top=top+1;
                items[top] = e;
            }
        }//Push

        public E pop() {
            if (isEmpty()==true) {
                System.out.println("Stack Empty!");
                }
            else{
              E e = (E) items[top];
              items[top] = null;
              top = top-1;
              return e;
            }
            return null;
        } //pop

        public boolean isFull() {
            if (top == items.length-1) {
                return true;
            }
            return false;
        } //isFull

        public boolean isEmpty(){
            if (top==-1) {
                return true;
            }
            return false;
        }//isEmpty


        @Override
        public String toString()
        {
            System.out.println("Array:");
            System.out.print("{");
            for(int i = 0; i < items.length ;i++) {
                System.out.print(items[i]+" ");
        }
            System.out.print("}");
            return "";
        }//toString

        public Boolean sameStack(StackArray<E> s2) {
            E t1, t2;
            //E iTop = this.items[top];
            //E i2Top= s2.items[top];
            int nTop = this.top; // 
            int n2Top= s2.top;  // nTop == n2Top is true even when elements are not equal
            boolean t = true;

            if(this.isEmpty() && s2.isEmpty()) {
                return t;
            }//if

            //This is the part I need to compare the elements
            if(nTop == n2Top) {
                t1 = this.pop()
                t2 = s2.pop();
//              t = sameStack(s2);
//              push(t1);
//              s2.push(t2);
            }   
            return t;
        }       


        public static void main(String[] args)
        {

            // Code reference for sameStack method
            StackArray<Integer> stack = new StackArray<Integer>();
            StackArray<Integer> stack2 = new StackArray<Integer>();

            stack.push(111);
            stack.push(222);
            stack.push(7177);
//          stack.push(40);
            stack2.push(444);
            stack2.push(555);
            stack2.push(777);
//          stack2.push(40);

            System.out.println(stack);
            System.out.println(stack2);

//          //Calling comparison method
            if (stack.sameStack(stack2) == true) {
                System.out.println("True, both stacks are equal.");
            }//if
            else {
                System.out.println("False, stacks are not equal.");
            }//else      
            System.out.println(stack);
            System.out.println(stack2);
        }//main

}//class

Answer 1

Если вам специально нужно использовать рекурсию для проверки равенства ваших стеков, то более простой способ - передать индекс методу. Тогда вам не нужно делать pu sh и всплывать.

public boolean equals(Stack<E> other) {
    return equalsFrom(other, 0);
}

private boolean equalsFrom(Stack<E> other, int from) {
    if (from >= this.top || from >= other.top)
        return from >= this.top && from >= other.top;
    else
        return this.items[from].equals(other.items[from])
            && equalsFrom(other, from + 1);
}

Надеюсь, этот метод имеет смысл для вас. Первая ветвь оператора if может быть прочитана как «если я достиг конца любого стека, то я должен достигнуть конца обоих стеков, чтобы они были равны». вторая ветвь может быть прочитана как «если я не достиг конца стека, то текущий элемент должен быть равен, а остальные стеки должны быть равны, чтобы все стеки были равны».

Answer 2

Губка Боб мем спустя много часов ........... наконец-то разобрался сам!

import java.util.NoSuchElementException;

public class StackArray<E> {

        private int top=-1;
        private static final int MAX_ITEMS = 10;
        private E items[];

        @SuppressWarnings("unchecked")
        public StackArray() {
            items = (E[]) new Object[MAX_ITEMS];
            System.out.println("Stack Created!");
        }

        public void push(E e) {
            if (isFull()==true) {
               System.out.println("Stack Full!");
            }
            else{
                top=top+1;
                items[top] = e;
            }
        }

        public E pop() {
             if (isEmpty()==true) {
                   System.out.println("Stack Empty!");
                }
             else{
            E e = (E) items[top];
            items[top] = null;
            top = top-1;
            return e;
             }
            return null;
        }

        public boolean isFull() {
             if (top == items.length-1) {
                 return true;
             }
             return false;
        }

        public boolean isEmpty(){
             if (top==-1) {
                 return true;
             }
             return false;
        }

        @Override
        public String toString()
        {
            System.out.println("Array:");
            System.out.print("{");
             for(int i = 0; i < items.length ;i++) {
                 System.out.print(items[i]+" ");
        }
             System.out.print("}");
            return "";
    }

        public int peek() {
            if (this.isEmpty()) throw new NoSuchElementException("Stack underflow");
            //System.out.println("items[top]"+this.items[top]);
            //System.out.println("e"+e);
            return (int) this.items[top];
        }


        public Boolean sameStack(StackArray<E> s2) {
            E t1, t2;
            boolean t = true;

            if(this.isEmpty() && s2.isEmpty()) {
                return t;
            }

            if ((int) this.peek() == s2.peek()) {
                t1 = this.pop();
                t2 = s2.pop();
                t = sameStack(s2);
                this.push(t1);
                s2.push(t2);
            }
            else {
                t = false;
                return t;
            }   
            return t;           
        }

        public static void main(String[] args) 
        {
            // Code reference for sameStack method
           StackArray<Integer> stack = new StackArray<Integer>();
           StackArray<Integer> stack2 = new StackArray<Integer>();

            stack.push(122);
            stack.push(222);
            stack.push(3313);
            stack.push(46);
            stack2.push(122);
            stack2.push(222);
            stack2.push(3313);
            stack2.push(46);
            System.out.println(stack);
            System.out.println(stack2);

            stack.peek();
            if (stack.sameStack(stack2) == true) {
                System.out.println("They are equal");
            }
            else {
                System.out.println("They are NOT equal");
            }

            System.out.println(stack);
            System.out.println(stack2);

            //Calling comparison method
           // stack.sameStack(stack2); 
        }
}

Answer 3

Просто итерируйте массив items и сравните элементы, используя equals() (не ==).

public boolean sameStack(StackArray<E> s2) {
    if (this.top != s2.top) {
        return false;
    }
    for (int i = 0; i <= this.top; i++) {
        if (! this.items[i].equals(s2.items[i])) {
            return false;
        }
    }
    return true;
}

Это работает, потому что любой метод StackArray может получить доступ к private членам из StackArray, будь то текущий экземпляр (this) или какой-либо другой экземпляр (например, s2).