day11打卡.有效的括号 and 删除字符串中的所有相邻重复项 and 逆波兰表达式求值

有效的括号

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

有效字符串需满足：

• 左括号必须用相同类型的右括号闭合。

• 左括号必须以正确的顺序闭合。

• 注意空字符串可被认为是有效字符串。

示例 1:

• 输入: "()"

• 输出: true

示例 2:

• 输入: "()[]{}"

• 输出: true

示例 3:

• 输入: "(]"

• 输出: false

示例 4:

• 输入: "([)]"

• 输出: false

示例 5:

• 输入: "{[]}"

• 输出: true

力扣20题

题外话

括号匹配是使用栈解决的经典问题。

题意其实就像我们在写代码的过程中，要求括号的顺序是一样的，有左括号，相应的位置必须要有右括号。

如果还记得编译原理的话，编译器在 词法分析的过程中处理括号、花括号等这个符号的逻辑，也是使用了栈这种数据结构。

再举个例子，linux系统中，cd这个进入目录的命令我们应该再熟悉不过了。

cd a/b/c/../../

这个命令最后进入a目录，系统是如何知道进入了a目录呢 ，这就是栈的应用（其实可以出一道相应的面试题了）

所以栈在计算机领域中应用是非常广泛的。

本题思路：

要考虑的情况一共有三种：

• 第一种：字符串里左方向的括号多余了 ，所以不匹配，对应栈里会多出右括号

• 第二种：括号没有多余，但是 括号的类型没有匹配上。

• 第三种：字符串里右方向的括号多余了，所以不匹配。

动画如下：

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

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

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

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

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

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

• 栈定义成char类型或者int类型，都可以，int类型是ascll码的形式存储，不影响

class Solution {
public:
    bool isValid(string s) {
        if(s.size()%2==1) return false; //如果s的长度为奇数，直接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(']');
            }
            // 第三种情况：遍历字符串匹配的过程中，栈已经为空了，没有匹配的字符了，说明右括号没有找到对应的左括号 return false
            // 第二种情况：遍历字符串匹配的过程中，发现栈里没有我们要匹配的字符。所以return false
            if(s[i]==')'||s[i]==']'||s[i]=='}'){   //两个细节点：1.里面if语句的条件判断一定是先判空，后比较与栈顶元素是否相等，防止栈为空的时候，对空栈操作而异常
                if(st.empty()||s[i]!=st.top()){     //2.不要将栈顶赋值给额外变量，也是防止对空栈进行操作
                    return false;     //如果还未变量完，遇到右括号，栈为空，或者遇见不匹配的，直接返回 
                }                          //eg:[{}]()))                      {[(}]}
                 st.pop();//如果相等且栈不为空，说明有左括号与之匹配，弹出即可
​
            }
        }
   // 第一种情况：此时我们已经遍历完了字符串，但是栈不为空，说明有相应的左括号没有右括号来匹配，所以return false，否则就return true
        return st.empty();     //进行栈判空，防止栈里面还有右括号(原字符串多了一个左括号) eg:({[]}()
    }
};

• 时间复杂度: O(n)

• 空间复杂度: O(n)

小改进

• 不用判断是否遇到右括号，在符合题意下，左括号完了之后一定会遇到右括号

class Solution {
public:
    bool isValid(string s) {
        if(s.size()%2!=0) return false; //如果s的长度为奇数，直接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(']');
            
            // 第三种情况：遍历字符串匹配的过程中，栈已经为空了，没有匹配的字符了，说明右括号没有找到对应的左括号 return false
            // 第二种情况：遍历字符串匹配的过程中，发现栈里没有我们要匹配的字符。所以return false
                                                     //两个细节点：1.里面if语句的条件判断一定是先判空，后比较与栈顶元素是否相等，防止栈为空的时候，对空栈操作而异常
            else if(st.empty()||s[i]!=st.top()) return false;   //2.不要将栈顶赋值给额外变量，也是防止对空栈进行操作
                      //如果还未变量完，遇到右括号，栈为空，或者遇见不匹配的，直接返回 
                                 //eg:[{}]()))                      {[(}]}
            else st.pop();//如果相等且栈不为空，说明有左括号与之匹配，弹出即可
                //直接else,上面的情况都不满足，肯定符合的，匹配的
            }
        
   // 第一种情况：此时我们已经遍历完了字符串，但是栈不为空，说明有相应的左括号没有右括号来匹配，所以return false，否则就return true
        return st.empty();     //进行栈判空，防止栈里面还有右括号(原字符串多了一个左括号) eg:({[]}()
    }
};

• 时间复杂度: O(n)

• 空间复杂度: O(n)

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

• 题目：

• 给出由小写字母组成的字符串 S，重复项删除操作会选择两个相邻且相同的字母，并删除它们。

  在 S 上反复执行重复项删除操作，直到无法继续删除。

  在完成所有重复项删除操作后返回最终的字符串。答案保证唯一。

  示例：

  • 输入："abbaca"

  • 输出："ca"

  • 解释：例如，在 "abbaca" 中，我们可以删除 "bb" 由于两字母相邻且相同，这是此时唯一可以执行删除操作的重复项。之后我们得到字符串 "aaca"，其中又只有 "aa" 可以执行重复项删除操作，所以最后的字符串为 "ca"。

  提示：

  • 1 <= S.length <= 20000

  • S 仅由小写英文字母组成。

• 力扣1047题

思路：

本题要删除相邻相同元素，相对于20.有效的括号来说其实也是匹配问题，20. 有效的括号 是匹配左右括号，本题是匹配相邻元素，最后都是做消除的操作。

本题也是用栈来解决的经典题目。

那么栈里应该放的是什么元素呢？

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

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

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

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

class Solution {
public:
    string removeDuplicates(string s) {  //用栈来解决
      stack<char> st;
      for(char str : s){
        if(st.empty()||str!=st.top()){   //如果栈为空，或栈顶元素不等于当前元素，直接入栈
            st.push(str);
        }else{
            st.pop();  // s 与 st.top()相等的情况，栈顶弹出即可
        }
      }
      string result="";
      while(!st.empty()){  // 将栈中元素放到result字符串汇总
        result=st.top()+result;     //或者添加完反转一下 reverse(str.begin(), str.end()); 
        st.pop();
      }
        return result;
    }
};

• 时间复杂度: O(n)

• 空间复杂度: O(n)

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

class Solution {
public:
    string removeDuplicates(string s) {  //用字符串当作栈来模拟解决
      string result;  //字符串的头部相当于栈的底部，尾部相当于栈的顶部
      for(char str : s){
        if(result.empty()||str!=result.back()){ //判断字符串为空第一次向字符串添加元素，
                                                //或str不等于当前字符串的尾部元素(也就是栈顶)
            result.push_back(str); //将该字符加入字符串尾部(也就是栈顶)
        }else{
            result.pop_back();  // str与 尾部元素相等的情况，直接将尾部元素(栈顶)弹出即可
        }
      }
     
        return result;//返回的就是正确顺序的字符串，省去了反转和将栈里字符变成字符串
    }
};

• 时间复杂度: O(n)

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

题外话

这道题目就像是我们玩过的游戏对对碰，如果相同的元素挨在一起就要消除。

可能我们在玩游戏的时候感觉理所当然应该消除，但程序又怎么知道该如何消除呢，特别是消除之后又有新的元素可能挨在一起。

此时游戏的后端逻辑就可以用一个栈来实现（没有实际考察对对碰或者爱消除游戏的代码实现，仅从原理上进行推断）。

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

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

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

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

双指针思想(java版本)

class Solution {
    public String removeDuplicates(String s) {
        char[] ch = s.toCharArray();
        int fast = 0;
        int slow = 0;
        while(fast < s.length()){
            // 直接用fast指针覆盖slow指针的值
            ch[slow] = ch[fast];
            // 遇到前后相同值的，就跳过，即slow指针后退一步，下次循环就可以直接被覆盖掉了
            if(slow > 0 && ch[slow] == ch[slow - 1]){
                slow--;
            }else{
                slow++;
            }
            fast++;
        }
        return new String(ch,0,slow);
    }
}

逆波兰表达式求值

根据 逆波兰表示法，求表达式的值。

有效的运算符包括 + , - , * , / 。每个运算对象可以是整数，也可以是另一个逆波兰表达式。

说明：

整数除法只保留整数部分。 给定逆波兰表达式总是有效的。换句话说，表达式总会得出有效数值且不存在除数为 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 2 3 4 5 6 7

逆波兰表达式：是一种后缀表达式，所谓后缀就是指运算符写在后面。

平常使用的算式则是一种中缀表达式，如 ( 1 + 2 ) * ( 3 + 4 ) 。

该算式的逆波兰表达式写法为 ( ( 1 2 + ) ( 3 4 + ) * ) 。

逆波兰表达式主要有以下两个优点：

• 去掉括号后表达式无歧义，上式即便写成 1 2 + 3 4 + * 也可以依据次序计算出正确结果。

• 适合用栈操作运算：遇到数字则入栈；遇到运算符则取出栈顶两个数字进行计算，并将结果压入栈中。

力扣150题

思路：

那么来看一下本题，其实逆波兰表达式相当于是二叉树中的后序遍历。 大家可以把运算符作为中间节点，按照后序遍历的规则画出一个二叉树。

但我们没有必要从二叉树的角度去解决这个问题，只要知道逆波兰表达式是用后序遍历的方式把二叉树序列化了，就可以了。

在进一步看，本题中每一个子表达式要得出一个结果，然后拿这个结果再进行运算，那么这岂不就是一个相邻字符串消除的过程，和1047.删除字符串中的所有相邻重复项中的对对碰游戏是不是就非常像了。

如动画所示：

相信看完动画大家应该知道，这和1047. 删除字符串中的所有相邻重复项是差不错的，只不过本题不要相邻元素做消除了，而是做运算！

class Solution {
public:
    int evalRPN(vector<string>& tokens) {
        stack<int> st;  
        for(int i=0;i<tokens.size();i++){
            if(tokens[i]=="*"){   //遇到* / + - 就从栈里取出前两个元素进行运算，细节：注意一定是取出的后一个元素在前，然后+ - * / 前一个元素，因为栈是先进后出 eg: ["4","13","5","/","+"] 原本除法是13/5,但是由于栈里面从顶到底的顺序是5 13 4 所以取出后若直接5 / 13 与题意不符，所以是后一个元素在先13/5 
                int num1=st.top();
                st.pop();
                int result=st.top()*num1;
                st.pop();
                st.push(result);
            }else if(tokens[i]=="/"){
                int num1=st.top();
                st.pop();
                int result=st.top()/num1;
                st.pop();
                st.push(result);   
            }else if(tokens[i]=="+"){
                 int num1=st.top();
                st.pop();
                int result=st.top()+num1;
                st.pop();
                st.push(result);
            }else if(tokens[i]=="-"){
                int num1=st.top();
                st.pop();
                int result=st.top()-num1;
                st.pop();
                st.push(result);
            }else{  // 不是符号就是数字，所以直接else，是数字就转为int后加入栈中
                int res = atoi(tokens[i].c_str()); //将字符串转为int
                st.push(res);
            }
​
        }
        return st.top(); //返回栈顶元素
​
    }
};

• 时间复杂度: 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] == "/"){   
//遇到* / + - 就从栈里取出前两个元素进行运算，细节：注意一定是取出的后一个元素num2在前，然后+ - * / 前一个元素num1，因为栈是先进后出 eg: ["4","13","5","/","+"] 原本除法是13/5,但是由于栈里面从顶到底的顺序是5 13 4 所以取出后若直接5 / 13 与题意不符，所以是后一个元素在先13/5 
               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{  // 不是符号就是数字，所以直接else，是数字就转为int后加入栈中
                int res = atoi(tokens[i].c_str()); //将字符串转为int
                st.push(res);
            }
​
        }
        int result = st.top();
        st.pop(); // 把栈里最后一个元素弹出（其实不弹出也没事）
        return result;
​
    }
};

• 时间复杂度: O(n)

• 空间复杂度: O(n)

题外话

我们习惯看到的表达式都是中缀表达式，因为符合我们的习惯，但是中缀表达式对于计算机来说就不是很友好了。

例如：4 + 13 / 5，这就是中缀表达式，计算机从左到右去扫描的话，扫到13，还要判断13后面是什么运算符，还要比较一下优先级，然后13还和后面的5做运算，做完运算之后，还要向前回退到 4 的位置，继续做加法，你说麻不麻烦！

那么将中缀表达式，转化为后缀表达式之后：["4", "13", "5", "/", "+"] ，就不一样了，计算机可以利用栈来顺序处理，不需要考虑优先级了。也不用回退了， 所以后缀表达式对计算机来说是非常友好的。

可以说本题不仅仅是一道好题，也展现出计算机的思考方式。

在1970年代和1980年代，惠普在其所有台式和手持式计算器中都使用了RPN（后缀表达式），直到2020年代仍在某些模型中使用了RPN。

参考维基百科如下：

During the 1970s and 1980s, Hewlett-Packard used RPN in all of their desktop and hand-held calculators, and continued to use it in some models into the 2020s.

总结：栈这种数据结构非常擅长做相邻字符的消除操作,当然相邻字符的要求不是唯一的,可以是括号匹配问题，可以是删除相邻重复项，也可以逆波兰表达式这种