java - Java中如何实现栈的反转？

Question

public class StackClass<T> implements StackADT<T>
{
    private int maxStackSize;  //variable to store the
                               //maximum stack size
    private int stackTop;      //variable to point to
                               //the top of the stack
    private T[] list;  //array of reference variables

       //Default constructor
       //Create an array of the size 100 to implement the stack.
       //Postcondition: The variable list contains the base
       //               address of the array, stackTop = 0,
       //               and maxStackSize = 100.
    public StackClass()
    {
        maxStackSize = 100;
        stackTop = 0;         //set stackTop to 0
        list = (T[]) new Object[maxStackSize]; //create the array
    }//end default constructor

       //Constructor with a parameter
       //Create an array of the size stackSize to implement the
       //stack.
       //Postcondition: The variable list contains the base
       //               address of the array, stackTop = 0,
       //               and maxStackSize = stackSize.
    public StackClass(int stackSize)
    {
        if (stackSize <= 0)
        {
            System.err.println("The size of the array to "
                             + "implement the stack must be "
                             + "positive.");
            System.err.println("Creating an array of the size 100.");

            maxStackSize = 100;
        }
        else
            maxStackSize = stackSize; //set the stack size to
                                      //the value specified by
                                      //the parameter stackSize
        stackTop = 0;    //set stackTop to 0
        list = (T[]) new Object[maxStackSize]; //create the array
    }//end constructor

       //Method to initialize the stack to an empty state.
       //Postcondition: stackTop = 0
    public void initializeStack()
    {
        for (int i = 0; i < stackTop; i++)
            list[i] = null;

        stackTop = 0;
    }//end initializeStack

       //Method to determine whether the stack is empty.
       //Postcondition: Returns true if the stack is empty;
       //               otherwise, returns false.
    public boolean isEmptyStack()
    {
        return (stackTop == 0);
    }//end isEmptyStack

       //Method to determine whether the stack is full.
       //Postcondition: Returns true if the stack is full;
       //               otherwise, returns false.
    public boolean isFullStack()
    {
        return (stackTop == maxStackSize);
    }//end isFullStack

       //Method to add newItem to the stack.
       //Precondition: The stack exists and is not full.
       //Postcondition: The stack is changed and newItem
       //               is added to the top of stack.
       //               If the stack is full, the method
       //               throws StackOverflowException
    public void push(T newItem) throws StackOverflowException
    {
        if (isFullStack())
            throw new StackOverflowException();

        list[stackTop] = newItem; //add newItem at the
                                  //top of the stack
        stackTop++;               //increment stackTop
    }//end push

       //Method to return a reference to the top element of
       //the stack.
       //Precondition: The stack exists and is not empty.
       //Postcondition: If the stack is empty, the method
       //               throws StackUnderflowException;
       //               otherwise, a reference to the top
       //               element of the stack is returned.
    public T peek() throws StackUnderflowException
    {
        if (isEmptyStack())
            throw new StackUnderflowException();

        return (T) list[stackTop - 1];
    }//end peek

       //Method to remove the top element of the stack.
       //Precondition: The stack exists and is not empty.
       //Postcondition: The stack is changed and the top
       //               element is removed from the stack.
       //               If the stack is empty, the method
       //               throws StackUnderflowException
    public void pop() throws StackUnderflowException
    {
        if (isEmptyStack())
           throw new StackUnderflowException();

        stackTop--;       //decrement stackTop
        list[stackTop] = null;
    }//end pop


}

我正在尝试实现一个reverseStack操作，该操作将一个堆栈的元素以相反的顺序复制到另一个堆栈上。到目前为止，我已经提出了以下内容...

public void reverseStack(StackClass<T> otherStack)
        {
           StackClass<T> newStack = new StackClass<T>();

           StackObj obj = null;
           while ( (obj = this.pop()) != null ) {
                      otherStack.push(obj);
                      newStack.push(obj);
           }

           // Now push back from newStack to this stack
           while ( (obj = newStack.pop() ) != null ) {
                     this.push(obj);
           }
        }

但是我的代码部分有问题

StackObj obj = null;
while ( (obj = this.pop()) != null ) {
    otherStack.push(obj);
    newStack.push(obj);
   }

因为 StackObj 类从未定义过。然而，我不知道还可以将 obj 定义为什么，因为我的 pop 过程不返回值。有什么想法吗？

谢谢(不，这不是家庭作业...我正在尝试通过练习自学 Java)。

Answer 1

您可以像这样直接使用类型 T:

public StackClass<T> reverseStack()
    {
       StackClass<T> newStack = new StackClass<T>();

       T obj = null;
       while ( (obj = this.pop()) != null ) {
                  newStack.push(obj);
       }

       return newStack; //Shallow reversed stack
    }

由于您的堆栈包含 T 类型的对象，因此您也应该像 T 一样威胁它们。

需要记住的事情Deep vs Shallow Copy 。你正在做一个浅拷贝，这是你想要的吗？ :)