代码随想录算法训练营第十天 | 栈与队列理论基础、232.用栈实现队列、225.用队列实现栈、20.有效的括号、1047.删除字符串中的所有相邻重复项

栈与队列理论基础

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

如图所示：

栈和队列是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（容器适配器）。

栈的底层实现可以是vector，deque，list 都是可以的， 主要就是数组和链表的底层实现。

我们常用的SGI STL，如果没有指定底层实现的话，默认是以deque为缺省情况下栈的底层结构。

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

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

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

 std::stack<int, std::vector<int> > third;  // 使用vector为底层容器的栈

刚刚讲过栈的特性，对应的队列的情况是一样的。

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

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

 std::queue<int, std::list<int>> third; // 定义以list为底层容器的队列

所以STL 队列也不被归类为容器，而被归类为container adapter（ 容器适配器）。

232.用栈实现队列

1、题目

2、题解

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

最后如何判断队列为空呢？如果进栈和出栈都为空的话，说明模拟的队列为空了。

 class MyQueue {
 public:
     stack<int> stIn;
     stack<int> stOut;
    
     MyQueue() {
 ​
     }
    
     void push(int x) {
         stIn.push(x);
     }
 ​
     
     int pop() {
         // 只有当stOut为空的时候，再从stIn里导入数据（导入stIn全部数据）
         if (stOut.empty()) {
             // 从stIn导入数据直到stIn为空
             while(!stIn.empty()) {
                 stOut.push(stIn.top());
                 stIn.pop();
             }
         }
         int result = stOut.top();
         stOut.pop();
         return result;
     }
 ​
 ​
     int peek() {
         int res = this->pop(); // 直接使用已有的pop函数
         stOut.push(res); // 因为pop函数弹出了元素res，所以再添加回去
         return res;
     }
 ​
   
     bool empty() {
         return stIn.empty() && stOut.empty();
     }
 };

3、总结

top()是取栈顶元素，不会删除里面的元素，返回栈顶的引用；

pop()是删除栈顶元素，返回void。

225.用队列实现栈

1、题目

2、题解

思路一：使用两个栈队列

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

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

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

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

模拟的队列执行语句如下：

 queue.push(1);        
 queue.push(2);        
 queue.pop();   // 注意弹出的操作       
 queue.push(3);        
 queue.push(4);       
 queue.pop();  // 注意弹出的操作    
 queue.pop();    
 queue.pop();    
 queue.empty();   

class MyStack {
 public:
     queue<int> que1;
     queue<int> que2; // 辅助队列，用来备份
    
     MyStack() {
 ​
     }
 ​
     void push(int x) {
         que1.push(x);
     }
 ​
     int pop() {
         int size = que1.size();
         size--;
         while (size--) { // 将que1 导入que2，但要留下最后一个元素
             que2.push(que1.front());
             que1.pop();
         }
 ​
         int result = que1.front(); // 留下的最后一个元素就是要返回的值
         que1.pop();
         que1 = que2;            // 再将que2赋值给que1
         while (!que2.empty()) { // 清空que2
             que2.pop();
         }
         return result;
     }
 ​
     int top() {
         return que1.back();
     }
 ​
     bool empty() {
         return que1.empty();
     }
 };

思路二：使用一个队列

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

 class MyStack {
 public:
     queue<int> que;
 ​
     MyStack() {
 ​
     }
 ​
     void push(int x) {
         que.push(x);
     }
 ​
     int pop() {
         int size = que.size();
         size--;
         while (size--) { // 将队列头部的元素（除了最后一个元素外） 重新添加到队列尾部
             que.push(que.front());
             que.pop();
         }
         int result = que.front(); // 此时弹出的元素顺序就是栈的顺序了
         que.pop();
         return result;
     }
  
     int top() {
         return que.back();
     }
 ​
     bool empty() {
         return que.empty();
     }
 };

20.有效的括号

1、题目

2、题解

由于栈结构的特殊性，非常适合做对称匹配类的题目。

首先要弄清楚，字符串里的括号不匹配有几种情况。

一些同学，在面试中看到这种题目上来就开始写代码，然后就越写越乱。

建议在写代码之前要分析好有哪几种不匹配的情况，如果不在动手之前分析好，写出的代码也会有很多问题。

先来分析一下 这里有三种不匹配的情况，

1. 第一种情况，字符串里左方向的括号多余了 ，所以不匹配。

2. 

3. 第二种情况，括号没有多余，但是 括号的类型没有匹配上。

4. 

5. 第三种情况，字符串里右方向的括号多余了，所以不匹配。

6. 

我们的代码只要覆盖了这三种不匹配的情况，就不会出问题，可以看出 动手之前分析好题目的重要性。

动画如下：

第一种情况：已经遍历完了字符串，但是栈不为空，说明有相应的左括号没有右括号来匹配，所以return false

第二种情况：遍历字符串匹配的过程中，发现栈里没有要匹配的字符。所以return false

第三种情况：遍历字符串匹配的过程中，栈已经为空了，没有匹配的字符了，说明右括号没有找到对应的左括号return false

那么什么时候说明左括号和右括号全都匹配了呢，就是字符串遍历完之后，栈是空的，就说明全都匹配了。

分析完之后，代码其实就比较好写了，

但还有一些技巧，在匹配左括号的时候，右括号先入栈，就只需要比较当前元素和栈顶相不相等就可以了，比左括号先入栈代码实现要简单的多了！

 class Solution {
 public:
     bool isValid(string s) {
         if (s.size() % 2 != 0) return false; // 如果s的长度为奇数，一定不符合要求
         stack<char> st;
         for (int i = 0; i < s.size(); i++) {
             if (s[i] == '(') st.push(')');
             else if (s[i] == '{') st.push('}');
             else if (s[i] == '[') st.push(']');
             // 第三种情况：遍历字符串匹配的过程中，栈已经为空了，没有匹配的字符了，说明右括号没有找到对应的左括号 return false
             // 第二种情况：遍历字符串匹配的过程中，发现栈里没有我们要匹配的字符。所以return false
             else if (st.empty() || st.top() != s[i]) return false;
             else st.pop(); // st.top() 与 s[i]相等，栈弹出元素
         }
         // 第一种情况：此时我们已经遍历完了字符串，但是栈不为空，说明有相应的左括号没有右括号来匹配，所以return false，否则就return true
         return st.empty();
     }
 };

3、总结

遇到左括号就添加右半边括号到栈中，遇到右括号就和栈头进行比较

1047.删除字符串中的所有相邻重复项

1、题目

2、题解

我们在删除相邻重复项的时候，其实就是要知道当前遍历的这个元素，我们在前一位是不是遍历过一样数值的元素，那么如何记录前面遍历过的元素呢？

所以就是用栈来存放，那么栈的目的，就是存放遍历过的元素，当遍历当前的这个元素的时候，去栈里看一下我们是不是遍历过相同数值的相邻元素。

然后再去做对应的消除操作。 如动画所示：

从栈中弹出剩余元素，此时是字符串ac，因为从栈里弹出的元素是倒序的，所以再对字符串进行反转一下，就得到了最终的结果。

class Solution {
 public:
     string removeDuplicates(string S) {
         stack<char> st;
         for (char s : S) {
             if (st.empty() || s != st.top()) {
                 st.push(s);
             } else {
                 st.pop(); // s 与 st.top()相等的情况
             }
         }
         string result = "";
         while (!st.empty()) { // 将栈中元素放到result字符串汇总
             result += st.top();
             st.pop();
         }
         reverse (result.begin(), result.end()); // 此时字符串需要反转一下
         return result;
 ​
     }
 };

当然可以拿字符串直接作为栈，这样省去了栈还要转为字符串的操作。

 class Solution {
 public:
     string removeDuplicates(string S) {
         string result;
         for(char s : S) {
             if(result.empty() || result.back() != s) {
                 result.push_back(s);
             }
             else {
                 result.pop_back();
             }
         }
         return result;
     }
 };

3、总结

把元素先入栈，然后比较后面的字符串是不是和栈头的元素相等，然后再去做对应的消除操作