随想录Day10--232.用栈实现队列 , 225. 用队列实现栈

今天的题目比较简单，是栈和队列的相互实现。其中用栈实现队列，需要用到两个栈，用队列实现栈，只需要一个队列。在互相实现的过程中，有几个细节需要注意：（1）用栈实现队列时，一定要把出栈的元素先全部弹出，再把入栈的元素转移到出栈里面。（2）入栈元素转移到出栈时，一定要把所有的入栈元素都转移过去，让入栈变成空，否则顺序就会乱。（3）用队列实现栈时，每增加一个元素时，先把元素加入队列，然后除了刚加进来的元素外，所有元素依次按顺序出队列再进队列，使刚加进来的元素变成第一个元素。（添加后马上进行循环）

232. 用栈实现队列

请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（push、pop、peek、empty）：

实现 MyQueue 类：

• void push(int x) 将元素 x 推到队列的末尾

• int pop() 从队列的开头移除并返回元素

• int peek() 返回队列开头的元素

• boolean empty() 如果队列为空，返回 true ；否则，返回 false

说明：

• 你 只能 使用标准的栈操作 —— 也就是只有 push to top, peek/pop from top, size, 和 is empty 操作是合法的。

• 你所使用的语言也许不支持栈。你可以使用 list 或者 deque（双端队列）来模拟一个栈，只要是标准的栈操作即可。

示例 1：

输入：

["MyQueue", "push", "push", "peek", "pop", "empty"]

[[], [1], [2], [], [], []]

输出：

[null, null, null, 1, 1, false]

解释：

MyQueue myQueue = new MyQueue();

myQueue.push(1); // queue is: [1]

myQueue.push(2); // queue is: [1, 2] (leftmost is front of the queue)

myQueue.peek(); // return 1

myQueue.pop(); // return 1, queue is [2]

myQueue.empty(); // return false

提示：

• 1 <= x <= 9

• 最多调用 100 次 push、pop、peek 和 empty

• 假设所有操作都是有效的 （例如，一个空的队列不会调用 pop 或者 peek 操作）

进阶：

• 你能否实现每个操作均摊时间复杂度为 O(1) 的队列？换句话说，执行 n 个操作的总时间复杂度为 O(n) ，即使其中一个操作可能花费较长时间。

class MyQueue {

    Deque<Integer> inStack;
    Deque<Integer> outStack;
    public MyQueue() { //初始化，new两个栈对象
        inStack = new ArrayDeque<Integer>();
        outStack = new ArrayDeque<Integer>();
    }
    
    public void push(int x) { //加入元素，直接加到入栈里
        inStack.push(x);
    }
    
    public int pop() {   //移除开头元素并返回值
        if(outStack.isEmpty()){ //要先把出栈的元素全部输出，空了在把入栈元素全部导入
           while(!inStack.isEmpty()){
           outStack.push(inStack.pop());
            }
        }
        return outStack.pop();
    }
    
    public int peek() {   //和移除开头元素类似，只是不用移除
        if(outStack.isEmpty()){
           while(!inStack.isEmpty()){
           outStack.push(inStack.pop());
            }
        }
        return outStack.peek();
    }
    
    public boolean empty() {  //入栈和出栈都是空，队列就是空
        return inStack.isEmpty() && outStack.isEmpty();

    }
}

225. 用队列实现栈

请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。

实现 MyStack 类：

• void push(int x) 将元素 x 压入栈顶。

• int pop() 移除并返回栈顶元素。

• int top() 返回栈顶元素。

• boolean empty() 如果栈是空的，返回 true ；否则，返回 false 。

注意：

• 你只能使用队列的基本操作 —— 也就是 push to back、peek/pop from front、size 和 is empty 这些操作。

• 你所使用的语言也许不支持队列。 你可以使用 list （列表）或者 deque（双端队列）来模拟一个队列 , 只要是标准的队列操作即可。

示例：

输入：

["MyStack", "push", "push", "top", "pop", "empty"]

[[], [1], [2], [], [], []]

输出：

[null, null, null, 2, 2, false]

解释：

MyStack myStack = new MyStack();

myStack.push(1);

myStack.push(2);

myStack.top(); // 返回 2

myStack.pop(); // 返回 2

myStack.empty(); // 返回 False

提示：

• 1 <= x <= 9

• 最多调用100 次 push、pop、top 和 empty

• 每次调用 pop 和 top 都保证栈不为空

进阶：你能否仅用一个队列来实现栈。

这道题的两种解题方法，一种是用双队列实现栈，一种是单队列。用双队列实现栈其中一个队列的作用是用来缓存除了刚进栈的其他元素。所以用单队列进行解决时，把除了新加入的元素外所有元素依次弹出再添加到队列里，放在后面也是可以的。

class MyStack {
    Queue<Integer> queue;
    public MyStack() {
        queue = new LinkedList<>();
    }
    
    public void push(int x) { //添加元素，这里一定要添加完后，就把其他所有元素重新入队
        queue.offer(x);
        for(int i = 0; i < queue.size() - 1; i++){
            queue.offer(queue.poll());
        } 
    }
    
    public int pop() {  //这时候队列输出已经是栈的输出，所以直接poll弹出第一个元素。
        return queue.poll();
    }
    
    public int top() {   //peek就是获取队列的第一个元素
        return queue.peek();
    }
    
    public boolean empty() {  //如果队列里面没元素了，那么对应的栈也是空
        return queue.isEmpty();
    }
}

用栈实现队列的流程

在push数据的时候，只要数据放进输入栈就好，但在pop的时候，操作就复杂一些，输出栈如果为空，就把进栈数据全部导入进来（注意是全部导入），再从出栈弹出数据，如果输出栈不为空，则直接从出栈弹出数据就可以了。

用队列实现栈的过程

队列是先进先出的规则，把一个队列中的数据导入另一个队列中，数据的顺序并没有变，并没有变成先进后出的顺序。

所以用栈实现队列， 和用队列实现栈的思路还是不一样的，这取决于这两个数据结构的性质。

但是依然还是要用两个队列来模拟栈，只不过没有输入和输出的关系，而是另一个队列完全用来备份的！

如下面动画所示，用两个队列que1和que2实现队列的功能，que2其实完全就是一个备份的作用，把que1最后面的元素以外的元素都备份到que2，然后弹出最后面的元素，再把其他元素从que2导回que1。

单队列实现栈

模拟入栈的实现原理 -- 栈的特性是新加入的元素出现在栈顶，保证后进先出。 -- 队列的特性为新加入的元素出现在队尾，队列的队尾元素最后出队。 -- 按以上两个前提，我们可以让队头至队尾前的其它所有元素依次出队再入队，直至在队尾新加入的元素被移到队头，也即实现了让新压入的元素保留在栈顶。