栈与队列：有效的括号 删除字符串中的所有相邻重复项 逆波兰表达式求值

有效的括号

• 题目：Leetcode20

• 思路：

  • 使用栈解决的问题：对称匹配类问题，还有编译器在词法分析的过程中处理括号、花括号等这个符号的逻辑，也是使用了栈这种数据结构。

  • 分析不匹配的所有情况：

    • 左括号多余

    • 右括号多余

    • 括号没有多余，但是类型不匹配

  • 不同情况在栈中的表现：遍历到左括号时，将相匹配的右括号放入栈中，只需要比较当前元素和栈顶相不相等就可以了

    • 左括号多余  ->  遍历完字符串，但是栈不为空，说明有相应的左括号没有右括号来匹配，所以return false

    • 右括号多余  ->  遍历未结束，但是栈已经为空，没有匹配的字符了，说明右括号没有找到对应的左括号return false

    • 括号没有多余  ->  发现栈顶元素不匹配，return false

  • 全部匹配成功的情况：字符串遍历结束，栈也清空了

• 时间复杂度：O(n)

• 空间复杂度：O(n)

class Solution {
public:
    bool isValid(string s) {
        //如果字符串长度为奇数，则一定不满足，直接返回
        if(s.size() % 2) return false;
        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('}');
            //如果遍历未结束，而栈变为空，说明右括号多余了，没有足够的左括号来匹配
            //如果遍历到右括号，与栈顶的右括号类型不同，则说明括号类型没有匹配上，括号没有以正确的顺序闭合
            else if(st.empty() || st.top() != s[i]) return false;
            else st.pop();//st.top() 与 s[i]相等，栈弹出元素
        }
        //如果遍历结束，而栈不为空，说明左括号多余了，没有足够的右括号来匹配
        //如果遍历结束，而栈为空，则为有效字符串
        return st.empty();
    }
};

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

• 题目：Leetcode1047

• 思路：使用栈存放遍历过的元素，当遍历当前的这个元素的时候，去栈里看一下我们是不是遍历过相同数值的相邻元素，再去做对应的消除操作。使用栈结构最后还要进行字符串反转，如果直接使用字符串模拟栈，就可以省去这一步操作。

• 使用stack：

//时间复杂度: O(n)
//空间复杂度: O(n)

class Solution {
public:
    string removeDuplicates(string S) {
        stack<char> st;
        string res = "";
        for(char s : S) {
            //如果此时栈为空，或者栈顶元素与遍历到的字符不同，则将该字符放入栈中
            if(st.empty() || s != st.top()) {
                st.push(s);
            }
            //如果栈顶元素与遍历到的字符相同，则弹出元素
            else {
                st.pop();
            }
        }
        //将栈中的元素弹出保存到字符串中
        while(!st.empty()) {
            res += st.top();
            st.pop();
        }
        //反转字符串
        reverse(res.begin(), res.end());
        return res;
    }
};

• 直接使用字符串：

//时间复杂度: O(n)
//空间复杂度: O(1)，返回值不计空间复杂度

class Solution {
public:
    string removeDuplicates(string S) {
        string res = "";
        for(char s : S) {
            //字符串的头部作为栈底，尾部作为栈顶
            if(res.empty() || s != res.back()) {
                res.push_back(s);
            }
            else {
                res.pop_back();
            }
        }
        return res;
    }
};

逆波兰表达式求值

• 题目：Leetcode150

• 思路：逆波兰表达式相当于是二叉树中的后序遍历。与上题相似，本题中每一个子表达式要得出一个结果，然后拿这个结果再进行运算，也就是一个相邻字符串消除的过程。

• 时间复杂度：O(n)

• 空间复杂度：O(n)

class Solution {
public:
    int evalRPN(vector<string>& tokens) {
        stack<long long> st;
        for(int i = 0; i < tokens.size(); i++) {
            if(tokens[i] == "+" || tokens[i] == "-" || tokens[i] == "*" || tokens[i] == "/") {
                long long num1 = st.top();
                st.pop();
                long long num2 = st.top();
                st.pop();
                if(tokens[i] == "+") st.push(num2 + num1);
                if(tokens[i] == "-") st.push(num2 - num1);
                if(tokens[i] == "*") st.push(num2 * num1);
                if(tokens[i] == "/") st.push(num2 / num1);
            }
            else {
                //stoll，string转化成long long int
                st.push(stoll(tokens[i]));
            }
        }
        int res = st.top();
        st.pop();
        return res;
    }
};

总结

对称匹配类问题适合使用栈解决。

参考链接

代码随想录：有效的括号  删除字符串中的所有相邻重复项  逆波兰表达式求值