Question

我知道这个问题曾多次询问过，但经过一个小时的搜索后我仍然有问题。

我想使用一个可以存储最多元素的lifo堆栈。在达到最大数量后，首先删除元素并将其替换为new，因此在第一个pop中我可以得到这个元素和在第二个我必须得到大小为1的元素。

我尝试了什么：

1）使用修改后的堆栈，如here所述。问题是它总是返回我添加的前5个元素（如果大小为5）。

class StackSizable<E> extends Stack<E>{

    int maxSize;
    StackSizable(int size)
    {
        super();
        this.maxSize=size;
    }

    @Override
    public E push(E elt) {
        super.push(elt);
        while (this.size() > this.maxSize) {
            this.removeElementAt(this.size() - 1);
        }
        return null;
    }
}

2 ）使用ArrayDeque，我没有看到与简单堆栈的任何差异，它没有设置任何限制（我使用它错了？）

ArrayDeque<State> lifo = new ArrayDeque<State>(5);
lifo.pop();
lifo.push(state);

我想在拼图游戏中使用它来实现撤消重做功能

解决了：我结束时使用固定大小的堆栈，如汤姆所说，主要是为了性能



public class FixedStack<T> {
     private T[] stack;
     private int size;
     private int top;
     private int popBalance = 0;//its used to see if all the elements have been popped

     public FixedStack(T[] stack) {
           this.stack = stack;
           this.top = 0;
           this.size = stack.length;
     }

     public void push(T obj) {
           if (top == stack.length)top = 0;
           stack[top] = obj;
           top++;
           if (popBalance < size - 1)popBalance++;
     }

     public T pop() {

          if (top - 1 < 0)top = size;
          top--;
          T ob = stack[top];
          popBalance--;
          return ob;
     }

     public void clear() {
          top = 0;
     }

     public int size() {
          return size;
     }

     public boolean poppedAll() {
          if (popBalance == -1)return true;
          return false;
     }
}

Answer 1

我认为最有效的方法是使用固定数组，其大小等于最大元素数，以及指向当前队列“顶部”的元素的索引。

当你添加一个新元素时，你将它添加到索引+ 1（必要时回到元素0）并可能覆盖一个不再适合的元素。当你弹出一个元素时，你会反过来。

这样，您的数据结构永远不必重新排序，您可以使用比集合更轻量级的数组。

Answer 2

达到最大尺寸时，您的行

this.removeElementAt(this.size() - 1);

然后立即删除最后一个被推送的元素（你刚刚推送），这是堆栈的顶部。您需要删除第一个元素（堆栈的底部）：

this.removeElementAt(0);

Java堆栈与元素限制

2 个答案: