代码随想录训练营D10-栈与队列篇 p1 | 232.用栈实现队列、 225. 用队列实现栈

（〇）理论基础

1.C++

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

文章讲解：https://programmercarl.com/%E6%A0%88%E4%B8%8E%E9%98%9F%E5%88%97%E7%90%86%E8%AE%BA%E5%9F%BA%E7%A1%80.html

栈和队列是STL（C++标准库）里面的两个数据结构。

C++标准库是有多个版本的，要知道我们使用的STL是哪个版本，才能知道对应的栈和队列的实现原理。

那么来介绍一下，三个最为普遍的STL版本：
1）HP STL 其他版本的C++ STL，一般是以HP STL为蓝本实现出来的，HP STL是C++ STL的第一个实现版本，而且开放源代码。
2）P.J.Plauger STL 由P.J.Plauger参照HP STL实现出来的，被Visual C++编译器所采用，不是开源的。
3）SGI STL 由Silicon Graphics Computer Systems公司参照HP STL实现，被Linux的C++编译器GCC所采用，SGI STL是开源软件，源码可读性甚高。
接下来介绍的栈和队列也是SGI STL里面的数据结构， 知道了使用版本，才知道对应的底层实现。

栈提供push 和 pop 等等接口，所有元素必须符合先进后出规则，所以栈不提供走访功能，也不提供迭代器(iterator)。 不像是set 或者map 提供迭代器iterator来遍历所有元素。
栈是以底层容器完成其所有的工作，对外提供统一的接口，底层容器是可插拔的（也就是说我们可以控制使用哪种容器来实现栈的功能）。
所以STL中栈往往不被归类为容器，而被归类为container adapter（容器适配器）。

那么问题来了，STL 中栈是用什么容器实现的？

从下图中可以看出，栈的内部结构，栈的底层实现可以是vector，deque，list 都是可以的， 主要就是数组和链表的底层实现。
我们常用的SGI STL，如果没有指定底层实现的话，默认是以deque为缺省情况下栈的底层结构。

deque是一个双向队列，只要封住一段，只开通另一端就可以实现栈的逻辑了。

SGI STL中 队列底层实现缺省情况下一样使用deque实现的。

我们也可以指定vector为栈的底层实现，初始化语句如下：

std::stack<int, std::vector > third; // 使用vector为底层容器的栈
刚刚讲过栈的特性，对应的队列的情况是一样的。

队列中先进先出的数据结构，同样不允许有遍历行为，不提供迭代器, SGI STL中队列一样是以deque为缺省情况下的底部结构。

也可以指定list 为起底层实现，初始化queue的语句如下：

std::queue<int, std::list> third; // 定义以list为底层容器的队列
所以STL 队列也不被归类为容器，而被归类为container adapter（ 容器适配器）。

2.java

Java中Stack类从Vector类继承，底层是用数组实现的线程安全的栈。栈是一种后进先出(LIFO)的容器，常用的操作push/pop/peek。

不过Java中用来表达栈的功能（push/pop/peek），更适用的是使用双端队列接口Deque，并用实现类ArrayDeque/LinkedList来进行初始化。

Deque<Integer> stack = new ArrayDeque<>();
Deque<Integer> stack = new LinkedList<>();

Stack、Vector都是线程安全的，所以消耗更大。
Deque线程不安全。
Stack从Vector继承的一个副作用是，暴露了set/get方法，可以进行随机位置的访问，这与Stack只能从尾巴上进行增减的本意相悖。
此外，Deque在转成ArrayList或者stream的时候保持了“后进先出”的语义，而Stack因为是从Vector继承，没有这个语义。

Stack<Integer> stack = new Stack<>();
Deque<Integer> deque = new ArrayDeque<>();

stack.push(1);
stack.push(2);
deque.push(1);
deque.push(2);

System.out.println(new ArrayList<>(stack)); // [1,2]
List<Integer> list1 = stack.stream().collect(Collectors.toList());//[1,2]

// deque转成ArrayList或stream时保留了“后进先出”的语义
System.out.println(new ArrayList<>(deque)); // [2,1]
List<Integer> list2 = deque.stream().collect(Collectors.toList());//[2,1]

（一） 232.用栈实现队列

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

题目/文章/视频链接

1. 思路

使用两个栈，实现队列的功能。一个输入栈，一个输出栈。
1）void push(int x) 将元素 x 推到队列的末尾。//将元素压入输入栈
2）boolean empty() 如果队列为空，返回 true ；否则，返回 false//如果两个栈都为空，则返回true，否则返回false

3）int pop() 从队列的开头移除并返回元素//由题意，空的队列不会调用这个方法，所以不用判空。若输出栈为空,则将输入栈中的内容都压入输出栈。再从输出栈中弹出一个元素。

4）int peek() 返回队列开头的元素//可以考虑在peek中调用pop,再将弹出的元素压回输出栈中。

2. 代码

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

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

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

    public int pop() {
        if(stackOut.isEmpty()){
            while(!stackIn.isEmpty()){
                int temp = stackIn.pop();
                stackOut.push(temp);
            }
        }
        return stackOut.pop();
    }

    public int peek() {
        int elem = pop();
        return stackOut.push(elem);
    }

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

（二） 225. 用队列实现栈

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

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

题目/文章/视频链接

1. 思路

使用一个队列实现栈。
实现 MyStack 类：

void push(int x) 将元素 x 压入栈顶。//将元素入队。
int pop() 移除并返回栈顶元素。//将队列中前n-1个元素都出队再入队，此时再出队一个元素即可实现功能。
int top() 返回栈顶元素。//调用pop()方法，再将刚pop的元素再入队。
boolean empty() 如果栈是空的，返回 true ；否则，返回 false 。//返回队列是否为空

2. 代码

class MyStack {
    private Deque<Integer> deque;

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

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

    public int pop() {
        int time = deque.size() - 1;
        while(time-- > 0){
            int temp = deque.pop();
            deque.push(temp);
        }
        return deque.pop();
    }

    public int top() {
        int temp = pop();
        deque.push(temp);
        return temp;
    }

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