代码随想录算法训练营第十天 | 栈与队列理论基础，232. 用栈实现队列，225. 用队列实现栈

栈与队列理论基础

了解一下 栈与队列的内部实现机制，文中是以C++为例讲解的。

文章讲解： 代码随想录

队列是先进先出，栈是先进后出。

232.用栈实现队列

大家可以先看视频，了解一下模拟的过程，然后写代码会轻松很多。

题目链接/文章讲解/视频讲解： 代码随想录

重点：

1. 使用两个栈，一个是入栈，一个是出战

思路：

1. 在push数据的时候，只要数据放进输入栈就好

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

class MyQueue {
    Stack<Integer> stackIn;
    Stack<Integer> stackOut;

    public MyQueue() {
        stackIn = new Stack<>();
        stackOut = new Stack<>();
    }

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

    public int pop() {
        // 判断出栈中是否存在元素
        // 不存在的话说明之前的元素都已经pop完了，得重新从入栈中加入
        if (stackOut.isEmpty()) {
            while (!stackIn.empty()) {
                stackOut.push(stackIn.pop());
            }
        }
        // 存在的话直接出栈pop出即可
        int result = stackOut.pop();
        return result;
    }

    public int peek() {
        // 先pop出来再加入回去
        int result = this.pop();
        stackOut.push(result);
        return result;
    }

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

 225. 用队列实现栈

可能大家惯性思维，以为还要两个队列来模拟栈，其实只用一个队列就可以模拟栈了。 

建议大家掌握一个队列的方法，更简单一些，可以先看视频讲解。

题目链接/文章讲解/视频讲解： 代码随想录

重点：

1. 两个队列完成

2. 一个队列完成

思路：

1. 两个队列完成

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

2. 一个队列完成

一个队列在模拟栈弹出元素的时候只要将队列头部的元素（除了最后一个元素外） 重新添加到队列尾部，此时再去弹出元素就是栈的顺序了。

// 两个队列实现
class MyStack {
    Deque<Integer> queue1;
    Deque<Integer> queue2;
    public MyStack() {
        queue1 = new ArrayDeque<>();
        queue2 = new ArrayDeque<>();
    }

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

    public int pop() {
        int size = queue1.size();
        // 要留下最后一个，所以先--
        size--;
        while (size > 0) {
            queue2.addLast(queue1.peekFirst());
            queue1.pollFirst();
            size--;
        }
        int result = queue1.pollFirst();
        // 还原回queue1
        queue1 = queue2;
        queue2 = new ArrayDeque<>();
        return result;
    }

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

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

// 一个队列实现
class MyStack {
    Deque<Integer> queue;

    public MyStack() {
        queue = new ArrayDeque<>();
    }

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

    public int pop() {
        int size = queue.size();
        // 因为最后一个就是栈顶的数，所以--
        size--;
        while (size > 0) {
            // 从头绕到尾巴去
            queue.addLast(queue.peekFirst());
            queue.pollFirst();
            size--;
        }
        int result = queue.pollFirst();
        return result;
    }

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

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