Question

所以我尝试用一个队列来实现一个堆栈，它似乎工作，但我不确定它是否有问题，因为我在网上看到的大多数解决方案使用两个队列。任何人都可以告诉我，如果我的实施有问题吗？

public class MyStack<T> {

/**
 * @param args
 */
private Queue<T> q = new LinkedList<T>();
public MyStack(){
}
public static void main(String[] args) {
    // TODO Auto-generated method stub
    MyStack<String> s = new MyStack<String>();
    s.push("1");
    s.push("2");
    s.push("3");
    s.push("4");
    System.out.println(s.pop());
    System.out.println(s.pop());
    System.out.println(s.pop());
    System.out.println(s.pop());
    System.out.println(s.pop());
}

public void push(T s){
    q.offer(s);         
}

public T pop(){
    int n = q.size();
    for(int i = 0; i < n-1; i++){
        q.offer(q.poll());              
    }
    return q.poll();
}
}

输出：
4
3
2
1
空

Answer 1

您应该使用Stack或Deque甚至是LinkedList。

实现自己只是......毫无意义。当然除非（正如@bas所建议的）你正在做一个关于数据结构的课程，在这种情况下你应该去Commando并从头开始实现你自己的结构。使用另一种结构，因为它几乎就像你想要制作的结构就像使用带螺丝的锤子一样。

如果你真的需要自己实现某些东西，那么这样的事情应该有效：

public class Stack<T> {
  private Entry top = null;

  private class Entry {
    final Entry up;
    final T it;

    public Entry(Entry up, T it) {
      this.up = up;
      this.it = it;
    }
  }

  public void push ( T it ) {
    top = new Entry(top, it);
  }

  public T pop () {
    if ( top == null ) {
      throw new EmptyStackException();
    }
    T it = top.it;
    top = top.up;
    return it;
  }
}

注意：这可能不是线程安全的。

Answer 2

您的解决方案效率低下，因为每次从中弹出内容时都必须遍历整个堆栈。（实际上，在删除最后的元素之前，必须遍历整个链表。）编辑：无论如何，Java的链表是双重链接的，所以这完全没有意义。

Answer 3

堆栈绝对没有理由使用两个队列。事实上，它只需要跟踪一个引用其下方节点的顶级节点。

代码似乎有效，但正如nachokk所说，这不是代码审查的网站。如果您遇到错误并需要帮助，本网站就会发布。

Answer 4

只有在进行基本队列操作（如enqueue和dequeue）时，才必须使用两个队列。当你可以使用其他方法，特别是迭代队列时，你可以只用一个队列，就像你一样。

Java：用一个队列实现堆栈，有什么问题吗？

4 个答案: