Day10 用栈实现队列+用队列实现栈

代码随想录算法训练营第8天 | 232.用栈实现队列、225. 用队列实现栈

232.用栈实现队列

题目链接

思路：

代码部分：

class MyQueue {

    Stack<Integer> stackIn;
    // stackOut用来模拟出队列的顺序
    Stack<Integer> stackOut;
    
    public MyQueue() {
        stackIn = new Stack<>();
        stackOut = new Stack<>();
    }

    public void push(int x) {
        stackIn.push(x);
    }

  

    /** Removes the element from in front of queue and returns that element. */
    public int pop() {
        toStackOut();
        return stackOut.pop();
    }

    /** Get the front element. */
    public int peek() {
        toStackOut();
        return stackOut.peek();
    }

    public boolean empty() {
        return stackIn.isEmpty() && stackOut.isEmpty();
    }

    // 如果stackOut为空，那么将stackIn中的元素全部放到stackOut中
    private void toStackOut(){
        if(!stackOut.isEmpty()) return;
        while(!stackIn.isEmpty()){
            stackOut.push(stackIn.pop());
        }
    }
}

225. 用队列实现栈

题目链接

思路：

可以用两个队列或者一个双端队列实现。但不管什么方法，都只有一个目的，就是模拟一个stack的顺序。

代码部分：

两个队列实现：

```
class MyStack {

    Queue<Integer> queue1; // 和栈中保持一样元素的队列
    Queue<Integer> queue2; 

    public MyStack() {
        queue1 = new LinkedList<>();
        queue2 = new LinkedList<>();
    }
    
    /** Push element x onto stack. */
    public void push(int x) {
        queue2.offer(x); // 先放在辅助队列中
        while (!queue1.isEmpty()){
            queue2.offer(queue1.poll());
        }
        // 最后交换queue1和queue2，将元素都放到queue1中
        Queue<Integer> queueTemp;
        queueTemp = queue1;
        queue1 = queue2;
        queue2 = queueTemp; 
    }
    
    /** Removes the element on top of the stack and returns that element. */
    public int pop() {
        return queue1.poll(); 
    }
    
    /** Get the top element. */
    public int top() {
        return queue1.peek();
    }
    
    public boolean empty() {
        return queue1.isEmpty();
    }
}
```

一个双端队列实现：

class MyStack {
    // Deque 接口继承了 Queue 接口
    // 所以 Queue 中的 add、poll、peek等效于 Deque 中的 addLast、pollFirst、peekFirst
    Deque<Integer> que;
    public MyStack() {
        que = new ArrayDeque<>();
    }

    public void push(int x) {
        que.addLast(x);
    }

    public int pop() {
        int size = que.size();
        size--;
        while(size-- > 0){
            que.add(que.peekFirst());
            que.pollFirst();
        }
        return que.pollFirst();
    }

    public int top() {
        return que.peekLast();
    }

    public boolean empty() {
        return que.isEmpty();
    }

}

知识点

队列和双端队列实现：
LinkedList是基于双向链表实现的，它提供了较好的插入和删除元素的性能，尤其在队列的头部和尾部。所以LinkedList作为队列的实现类是很合适的。LinkedList可以高效地在队列的末尾添加元素（offer()方法）和移除队列的头部元素（poll()方法）。此外，LinkedList还提供了用于获取队列头部元素（peek()方法）和在特定位置插入、删除元素的方法。

ArrayDeque是基于数组实现的双端队列，它提供了较好的随机访问性能和一致的高效性能。ArrayDeque在队列的两端（开头和末尾）都能提供高效的插入和删除操作。它可以用作Queue和Deque的实现类，但在Deque场景下，ArrayDeque的性能更好，因为它支持在两端快速插入和删除元素，如addFirst()、addLast()、removeFirst()和removeLast()方法。如果需要频繁在队列两端进行插入和删除操作，使用ArrayDeque作为Deque的实现类更为合适。