代码随想录第七天|栈与队列（1）

目录

LeetCode 232. 用栈实现队列

LeetCode 225. 用队列实现栈

LeetCode 20. 有效括号

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

LeetCode 150. 逆波兰表达式求值

---

LeetCode 232. 用栈实现队列

题目链接：LeetCode 232. 用栈实现队列

思想：栈是先入后出，只有一个口；而队列是先入先出，有两个口。所以本题可以采用两个栈来实现队列，一个用来入数据——sIn，另一个用来出数据——sOut。push()函数，就调用sIn.push()，将元素压入这个栈里面。pop()函数，如果sOut这个栈是空的，就把sIn这个栈里面的元素全部弹出到sOut里面；如果sOut这个栈不为空，就直接弹出里面的顶层元素。peek()函数，把顶层元素pop出来之后，再压回去就行了。empty()函数，当两个栈都为空的时候，这个队列才为空。

代码如下：

public:
    stack<int> sIn;
    stack<int> sOut;
    MyQueue() {

    }
    
    void push(int x) {
        sIn.push(x);
    }
    
    int pop() {
        if (sOut.empty()){
            while(!sIn.empty()){
                sOut.push(sIn.top());
                sIn.pop();
            }
        }
        int res = sOut.top();
        sOut.pop();
        return res;
    }
    
    int peek() {
        int res = this->pop();
        sOut.push(res);
        return res;
    }
    
    bool empty() {
        return sIn.empty() && sOut.empty();
    }
};

LeetCode 225.
用队列实现栈

题目链接：LeetCode 225. 用队列实现栈

思想：同上一题思想，队列两个口，栈一个口，按理说只要把队列的其中一个口堵住，就可以完成栈的思想了。但本题需要另一个队列来存储数据，也就是说，如果需要pop出一个元素的话，需要把这个元素前面的所有元素转移到另一个队列中，再单独存储这个需要被pop的元素，并把它从队列中移除，最后再从另一个队列里面把元素再存储到这个队列中。push()函数和empty()函数就分别采取本来就有的库函数。top()函数，就采取队列的取尾函数就行了。

代码如下：

public:
    queue<int> que1;
    queue<int> que2;

    MyStack() {

    }
    
    void push(int x) {
        que1.push(x);
    }
    
    int pop() {
        int size = que1.size();
        while (--size){
            int temp = que1.front();
            que1.pop();
            que2.push(temp);
        }
        int result = que1.front();
        que1.pop();
        que1 = que2;
        while (!que2.empty()){
            que2.pop();
        }
        return result;
    }
    
    int top() {
        return que1.back();
    }
    
    bool empty() {
        return que1.empty();
    }
};

LeetCode 20. 有效括号

题目链接：LeetCode 20. 有效连接

思想：本题需要先想清楚的是什么样的才是无效的括号，无非就是以下三种情况：

1. 多的左括号
2. 多的右括号
3. 括号匹配不上

如果说像非常普通的1.2.情况的话，类似于四个左括号，三个右括号这种。字符串长度为奇数，肯定会发生有匹配不上的情况。所以可以上来先判断字符串长度的奇偶性。栈在算式运算这方面有着天然的运用场景，所以本题采用栈来存储遍历过的括号非常有效。在遍历字符串的过程中，无非是以下情况：

1. 遇到左括号
2. 遇到右括号

第一种情况，我们就采取把左括号对应的右括号放进栈。为什么不把左括号放进栈，是因为这样方便做字符串之间的比较，比较会比匹配容易操作。

第二种情况，我们就把右括号与栈顶元素进行比较，如果相等就弹出栈顶元素；反之就返回false。因为对应的左括号匹配不上右括号。还有种情况就是，遇到右括号，结果栈空了，很明显就是多的右括号，就直接返回false。

最后返回的时候，直接返回栈是否为空，以免会有多的左括号导致的右括号放进栈里面。

代码如下：

    bool isValid(string s) {
        if (s.size() % 2 != 0){
            return false;
        }
        stack<char> result;
        for (int i = 0; i < s.size(); i++){
            if (s[i] == '('){
                result.push(')');
            }else if (s[i] == '['){
                result.push(']');
            }else if (s[i] == '{'){
                result.push('}');
            }else if (result.empty() || result.top() != s[i]){
                return false;
            }else{
                result.pop();
            }
        }
        return result.empty();
    }

时间复杂度：O(n)，空间复杂度：O(n)。

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

题目链接：LeetCode 1047. 删除字符串中的所有相邻重复项

思想：本题也是用栈的经典用法（其实感觉用队列会更好一点）。遍历字符串中的字符，如果字符与栈顶元素相等的话，就让栈顶元素出栈；反之就入栈。然后用字符串将栈顶元素拼接成一个新的字符串。此时与目标字符串是相反的，所以这里需要反转一下字符串。（很明显用队列的话好像不用反转这一下）。

代码如下：

    string removeDuplicates(string s) {
        stack<char> result;
        for (int i = 0; i < s.size(); i++){
            if ( !result.empty() && result.top() == s[i]){
                result.pop();
            }else{
                result.push(s[i]);
            }
        }
        string str = "";
        while (!result.empty()){
            str += result.top();
            result.pop();
        }
        reverse(str.begin(), str.end());
        return str;
    }

时间复杂度：O(n)，空间复杂度：O(n)。

LeetCode 150. 逆波兰表达式求值

题目链接：LeetCode 150. 逆波兰表达式求解

思想：本题的主要思想就是，遇到数字就压入栈，遇到运算符就弹出栈顶两个元素进行相应操作，需要注意的是，每次进行运算操作的时候，把第二个弹出的数字放在前面，即b x a这种。其他的就没啥需要注意的了。

代码如下：

    int evalRPN(vector<string>& tokens) {
        stack<long long> stk;
        for (int i = 0; i < tokens.size(); i++){
            if (tokens[i] == "+" || tokens[i] == "-" || tokens[i] == "*" || tokens[i] == "/"){
                int a = stk.top();
                stk.pop();
                int b = stk.top();
                stk.pop();
                if (tokens[i] == "+") stk.push(b + a);
                else if (tokens[i] == "-") stk.push(b - a);
                else if (tokens[i] == "*") stk.push(b * a);
                else if (tokens[i] == "/") stk.push(b / a);
                
            }else {
                stk.push(stoi(tokens[i]));
            }
        }
        int temp = stk.top();
        return temp;
    }

时间复杂度：O(n)，空间复杂度：O(n)。

总结

栈这个东西，基本上都是最广泛应用的。能应用好还是很有效的。