算法训练Day11|栈与队列part02(LeetCode20. 有效的括号、LeetCode1047. 删除字符串中的相邻重复项、LeetCode150. 逆波兰表达式求值)

---

20. 有效的括号

题目链接
给定一个只包括 ‘(’，‘)’，‘{’，‘}’，‘[’，‘]’ 的字符串，判断字符串是否有效。

有效字符串需满足：

左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
注意空字符串可被认为是有效字符串。
示例 1:
输入: “()[]{}”
输出: true

示例 2:
输入: “(]”
输出: false

示例 3:
输入: “([)]”
输出: false

示例 4:
输入: “{[]}”
输出: true

1.思路分析

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

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

三种不匹配的情况

1. 左右括号不匹配
   如：( [ { } } } 、( [ ) ]
   遍历字符串匹配的过程中，发现栈里没有要匹配的字符。所以return false。

2. 左方向的括号多余
   如：( [ { } ] ( )
   已经遍历完了字符串，但是栈不为空，说明有相应的左括号没有右括号来匹配，所以return false。

3. 右方向的括号多余
   如：（ [ { } ] ) ) ) 、) (
   遍历字符串匹配的过程中，栈已经为空了，没有匹配的字符了，说明右括号没有找到对应的左括号return false。
   
   遇到左括号，就把右括号push进栈里，再遇到右括号时，就方便直接与这时候的栈顶元素top()对比。不用再对栈顶元素进行判断，再左变右， 比较麻烦。
   可以剪枝处理，如果字符串长度是奇数，直接return。

2.代码实现

class Solution {
public:
    bool isValid(string s) {
        stack<char> sta;
        if(s.size()%2) return false;
        for(int i=0;i<s.size();i++){
            if(s[i]=='(')  sta.push(')');
            else if(s[i]=='{') sta.push('}');
            else if(s[i]=='[') sta.push(']');
            // 第一种情况：发现栈里没有我们要匹配的字符。
            // 第三种情况：栈已经为空了，没有匹配的字符了，说明右括号没有找到对应的左括号
            else if(sta.empty()||s[i]!=sta.top()) return false;
            else sta.pop();    
        }
        // 第一种情况：已经遍历完了字符串，但是栈不为空，说明有相应的左括号没有右括号来匹配
        return sta.empty();
    }
};

记录一个错误

else if(sta.empty()||s[i]!=sta.top()) return false;

如果写成：

else if(sta.empty()||s[i]!=sta.top()) return false;

会错，因为如果不提前判断栈是否为空，就进行top()操作，就是在操作空栈。

3.复杂度分析

• 时间复杂度: O(n)
  字符串长度为N，里面的元素需要都遍历一遍，因此时间复杂度为O(N）；
• 空间复杂度: O(n)
  需要一个栈来储存元素，大小是O(N）级别的，总体来说的空间复杂度也为O(N）。

4.总结思考

技巧性的东西没有固定的学习方法，还是要多看多练，自己灵活运用了。

本题学习时间⌛️：80min

---

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

题目链接
给出由小写字母组成的字符串 S，重复项删除操作会选择两个相邻且相同的字母，并删除它们。
在 S 上反复执行重复项删除操作，直到无法继续删除。
在完成所有重复项删除操作后返回最终的字符串。答案保证唯一。

示例：
输入：“abbaca”
输出：“ca”
解释：例如，在 “abbaca” 中，我们可以删除 “bb” 由于两字母相邻且相同，这是此时唯一可以执行删除操作的重复项。之后我们得到字符串 “aaca”，其中又只有 “aa” 可以执行重复项删除操作，所以最后的字符串为 “ca”。
提示：
1 <= S.length <= 20000
S 仅由小写英文字母组成。

1.思路分析

和上道题有异曲同工之处，上道题是相邻括号的匹配，这是相邻字母的匹配，思路是一样的。

栈的作用

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

优化方法

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

如果想优化这种反转的步骤，可以考虑直接用字符串模拟栈的结构，所有操作只在字符串的尾部，push back & pop back，最后直接返回这个字符串就可以了。

2.代码实现

用栈：

class Solution {
public:
    string removeDuplicates(string s) {
        stack<char> st;
        for(int i=0;i<s.size();i++){
            if(st.empty()||s[i]!=st.top()) st.push(s[i]);
            else if(s[i]==st.top()) st.pop();
        }
        string result="";
        while(!st.empty()){
            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()||s!=result.back()) result.push_back(s);
            else if(s==result.back()) result.pop_back();
        }
        return result;
    }
};

3.复杂度分析

用栈

时间复杂度：O(N)
字符串长度为N，里面的元素需要都遍历一遍，因此时间复杂度O(N）；

空间复杂度：O(N)
额外需要一个字符串储存，长度数量级也为O(N)

用字符串模拟栈

时间复杂度：O(N)
字符串长度为N，里面的元素需要都遍历一遍，因此时间复杂度为O(N）；

空间复杂度：O(N)
额外需要一个字符串储存，长度数量级也为O(N)

4.总结思考

这道题目就像是我们玩过的游戏对对碰，如果相同的元素挨在一起就要消除。此时游戏的后端逻辑就可以用一个栈来实现。

编程语言的一些功能实现也会使用栈结构，实现函数递归调用就需要栈，但不是每种编程语言都支持递归，例如：

递归的实现就是：每一次递归调用都会把函数的局部变量、参数值和返回地址等压入调用栈中，然后递归返回的时候，从栈顶弹出上一次递归的各项参数，所以这就是递归为什么可以返回上一层位置的原因。

一种错误就是栈溢出，系统输出的异常是Segmentation fault（当然不是所有的Segmentation fault 都是栈溢出导致的） ，如果使用了递归，就要想一想是不是无限递归了，那么系统调用栈就会溢出。

在企业项目开发中，尽量不要使用递归！在项目比较大的时候，由于参数多，全局变量等等，使用递归很容易判断不充分return的条件，非常容易无限递归（或者递归层级过深），造成栈溢出错误（这种问题还不好排查！）

本题学习时间⌛️：60min

---

150. 逆波兰表达式求值

题目链接
根据 逆波兰表示法，求表达式的值。
有效的运算符包括 + , - , * , / 。每个运算对象可以是整数，也可以是另一个逆波兰表达式。

说明：
整数除法只保留整数部分。 给定逆波兰表达式总是有效的。换句话说，表达式总会得出有效数值且不存在除数为 0 的情况。

示例 1：
输入: [“2”, “1”, “+”, “3”, " * "]
输出: 9
解释: 该算式转化为常见的中缀算术表达式为：((2 + 1) * 3) = 9
示例 2：
输入: [“4”, “13”, “5”, “/”, “+”]
输出: 6
解释: 该算式转化为常见的中缀算术表达式为：(4 + (13 / 5)) = 6
示例 3：
输入: [“10”, “6”, “9”, “3”, “+”, “-11”, " * ", “/”, " * ", “17”, “+”, “5”, “+”]
输出: 22
解释:该算式转化为常见的中缀算术表达式为：

((10 * (6 / ((9 + 3) * -11))) + 17) + 5       
= ((10 * (6 / (12 * -11))) + 17) + 5       
= ((10 * (6 / -132)) + 17) + 5     
= ((10 * 0) + 17) + 5     
= (0 + 17) + 5    
= 17 + 5    
= 22   

1.思路分析

逆波兰表达式是什么？

逆波兰表达式：是一种后缀表达式，所谓后缀就是指运算符写在后面。
平常使用的算式是一种中置表达式，如 ( 1 + 2 ) X( 3 + 4 ) 。
逆波兰表达式是二叉树的后序遍历，把运算符作为中间节点，后序遍历是左右中，写法为 ( ( 1 2 + ) ( 3 4 + )X) 。

逆波兰的作用

逆波兰是方便计算机运算的一种方式，
例如：4 + 13 / 5，这就是中缀表达式，计算机从左到右去扫描的话，扫到13，还要判断13后面是什么运算符，还要比较一下优先级，然后13还和后面的5做运算，做完运算之后，还要向前回退到 4 的位置，继续做加法。
而后缀表达式[“4”, “13”, “5”, “/”, “+”] ，是没有括号的，也不需要考虑优先级了

逆波兰适合用栈操作

如果没接触过逆波兰表达式，是想不到用栈来解决。
遇到数字就进栈，遇到操作符就从栈里取出两个元素做运算，再将结果push进栈。
这样就实现了每个子表达式都得出一个结果，在拿这个结果进行运算。这个过程和上道题删除字符串中的所有相邻重复项中的对对碰游戏思想上是非常类似的，只不过相邻元素消除变为得出一个运算结果。

2.代码实现

class Solution {
public:
    int evalRPN(vector<string>& tokens) {
        stack<int> st;
        for(int i=0;i<tokens.size();i++){
            if(tokens[i]=="+"||tokens[i]=="-"||tokens[i]=="*"||tokens[i]=="/") {
                int num1=st.top();
                st.pop();
                int num2=st.top();
                st.pop();
                //注意这里后弹出的num2是二叉树左子节点
                //num1和num2的顺序不要写错了
                if(tokens[i]=="+") st.push(num2+num1);
                else if(tokens[i]=="-") st.push(num2-num1);
                else if(tokens[i]=="*") st.push(num2*num1);
                else if(tokens[i]=="/") st.push(num2/num1);
            }
            else  st.push(stoi(tokens[i]));
        }
        int result =st.top();
        return result;
    }
};

3.复杂度分析

• 时间复杂度：O(N)
  需要从头到尾遍历一遍逆波兰表达式然后做相应的处理，时间复杂度为O(N）

• 空间复杂度：O(N)
  需要另外一个栈，来保存逆波兰表达式的元素，空间复杂度O(N）

4.总结思考

后缀表达式对计算机来说是非常友好的。可以说本题不仅仅是一道好题，也展现出计算机的思考方式。
递归就是用栈来实现的。所以栈与递归之间在某种程度上是可以转换的！ 这一点在后续学习二叉树的时候，还会更详细的看到。
通篇可以看出来栈这种结构擅长之处，就是匹配问题。

本题学习时间⌛️：80min

---