【算法练习Day10】有效的括号&&删除字符串中的所有相邻重复项&&逆波兰表达式求值

​📝个人主页：@Sherry的成长之路
🏠学习社区：Sherry的成长之路（个人社区）
📖专栏链接：练题
🎯长路漫漫浩浩，万事皆有期待

有效的括号

20. 有效的括号

这道题相信学过数据结构的同学应该并不陌生，这道题是一道在学习栈的时候的一道十分经典的题型，起初第一次接触的时候，多少会有点感觉难，现在做来还行的。

题目要求就是将所有的括号匹配起来，主要有两种情况会匹配失败：
一种是左括号或者右括号出现多余的情况，另一种情况是前一个括号与后一个括号不能连续匹配，我们可以根据栈这个数据结构的特点，使左括号字符都放进去，遇到右括号的时候，top一下看看栈顶元素是否为相匹配的左括号，如果相匹配我们将其弹出栈，然后接着遍历，如果不匹配我们直接return false

注意：如果在碰到右括号时候栈为空则说明栈中没有左括号，那么此时直接弹出，说明右括号有多余的。如果将整个字符都遍历完了，依然没有return，那么则说明第二种情况已经判断完毕，并没有括号不匹配的情况出现，但是此时并不代表就一定没有错误，当匹配完毕之后如果栈中还剩下括号说明左括号有多余的。

class Solution {
public:
    bool isValid(string s) 
    {
        stack<int> arr1;
        for(int i=0;i<s.size();i++)
        {
            if(s[i]!=')'&&s[i]!='}'&&s[i]!=']')
            {
                arr1.push(s[i]);
            }
            if(s[i]==')')
            {
                if(arr1.empty()==true||arr1.top()!='(')
                {
                    return false;
                }
                else
                {
                    arr1.pop();
                }
            }
            if(s[i]=='}')
            {
                if(arr1.empty()==true||arr1.top()!='{')
                {
                    return false;
                }
                else
                {
                    arr1.pop();
                }
            }
            if(s[i]==']')
            {
                if(arr1.empty()==true||arr1.top()!='[')
                {
                    return false;
                }
                else
                {
                    arr1.pop();
                }
            }
            
        }
        if(arr1.empty()==true)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

还有另一种思路：在遇到左括号时候往栈里直接加入右括号，然后碰到右括号时候在进行判断，和上一种思路基本上是一样的。

class Solution {
public:
    bool isValid(string s) {
        if(s.size()%2!=0)
        {// 如果s的长度为奇数，一定不符合要求
            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(']');
            }
             // 第二种情况：遍历字符串匹配的过程中，发现栈里没有我们要匹配的字符。所以return false
             // 第三种情况：遍历字符串匹配的过程中，栈已经为空了，没有匹配的字符了，说明右括号没有找到对应的左括号 return false
            else if(st.empty()||st.top()!=s[i])
            {
                return false;
            }
            else
            { // st.top() 与 s[i]相等，栈弹出元素
                st.pop();
            }
        }
         // 第一种情况：此时我们已经遍历完了字符串，但是栈不为空，说明有相应的左括号没有右括号来匹配，所以return false，否则就return true
        return st.empty();
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

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

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

这道题是消除字符串中连续的字符，只要有相邻重复就直接删除，所以并不是我们第一眼看到只有一处相邻相同字符就只删一次，可能在删除一处之后又有新的元素碰到一起，这时栈派上了用场，它可以存储我们遍历过的数据，我们只需要判断当前遍历的数据是否和栈顶元素一样，一致就将其弹出，这样不仅解决了表面的相邻相同字符消去，当消去后如果有两个新的相邻相同元素碰到一起了，我们也能发现并消除他们，一举多得。

class Solution {
public:
    string removeDuplicates(string s) {
        stack<int> st;
        for(char s1:s)
        {
            if(st.empty()||s1!=st.top())
            {
                st.push(s1);
            }
            else
            {
                st.pop();// s 与 st.top()相等的情况
            }
        }
        string result="";
        while(!st.empty())
        {// 将栈中元素放到result字符串汇总
            result+=st.top();
            st.pop();
        }
        reverse(result.begin(),result.end()); // 此时字符串需要反转一下
        return result;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

上面的代码我们用字符串来模拟栈的一个实现，让字符串的头部充当栈底，尾部充当栈顶，这样做的好处是避免了直接使用栈的时候数据元素是倒序且还要转换为字符串输出。

class Solution {
public:
    string removeDuplicates(string s) {
        string result;
        for(char s1:s)
        {
            if(result.empty()||result.back()!=s1)
            {
                result.push_back(s1);
            }
            else
            {
                result.pop_back();
            }
        }
        return result;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

逆波兰表达式求值

150. 逆波兰表达式求值

逆波兰表达式求值，这道题的难度是中等题，并不是是它有多么难的思路，而是如果你没有接触到这个题，不是很容易想到解题思路，逆波兰表达式，实际上就是一种后缀表达式，可以把我们日常熟悉的一个等式（1+2）* （3*4）看成中序表达式，画树形图很容易得出，那么后续表达式大题运算思路就是两个数遇到符号再进行运算操作，没遇到符号时候先保留起来，每次遇到符号拿出两个操作数操作，这种思路很适用于栈的数据结构。

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]=="/")
            {
                long long num1=st.top();
                st.pop();
                long long num2=st.top();
                st.pop();
                if(tokens[i]=="+")
                {
                    st.push(num1+num2);
                }
                if(tokens[i]=="-")
                {
                    st.push(num2-num1);
                }
                if(tokens[i]=="*")
                {
                    st.push(num2*num1);
                }
                if(tokens[i]=="/")
                {
                    st.push(num2/num1);
                }
            }
            else
            {
                st.push(stoll(tokens[i]));//在C++中，std::stoll函数用于将字符串转换为长整型（long long）数据类型。
            }
        }
        int result= st.top();
        st.pop();// 把栈里最后一个元素弹出（其实不弹出也没事）
        return result;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

具体代码如上，在未碰到操作符时，将数字入栈，遇到操作符再取出两个操作符，值得注意的是操作数顺序很重要是第二个操作数相对于第一个操作数来进行操作，数据放入里的stoll函数，作用是将字符串转换为long数据类型。此外这道题并不需要我们来判断传输进来的数据是否合法，只需要我们写出判断字符和数据的代码即可。

总结：

今天我们完成了有效的括号、删除字符串中的所有相邻重复项、逆波兰表达式求值三道题目，相关的思想需要多复习回顾。接下来，我们继续进行算法练习·。希望我的文章和讲解能对大家的学习提供一些帮助。

当然，本文仍有许多不足之处，欢迎各位小伙伴们随时私信交流、批评指正！我们下期见~