代码随想录算法训练营第十一天| 20. 有效的括号、1047. 删除字符串中的所有相邻重复项、150. 逆波兰表达式求值

20. 有效的括号

public static bool IsValid(string s)
        {
            Dictionary<char, char> dict = new Dictionary<char, char>();
            dict.Add(')', '(');
            dict.Add(']', '[');
            dict.Add('}', '{');
            var result = true;
            Stack<char> stack = new Stack<char>();
            for (int i = 0; i < s.Length; i++)
            {
                if (s[i] == '(' || s[i] == '{' || s[i] == '[')//如果是左括号，直接入栈
                {
                    stack.Push(s[i]);
                    continue;
                }

                if (stack.Count == 0 || stack.Pop() != dict[s[i]])//如果是右括号，弹出栈顶元素比较
                {
                    result = false;
                    break;
                }
            }
            return result && stack.Count == 0;//最后栈需要为空
        }

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

题外话:
这道题目就像是我们玩过的游戏对对碰，如果相同的元素放在挨在一起就要消除。
递归的实现就是：每一次递归调用都会把函数的局部变量、参数值和返回地址等压入调用栈中，然后递归返回的时候，从栈顶弹出上一次递归的各项参数，所以这就是递归为什么可以返回上一层位置的原因。
相信大家应该遇到过一种错误就是栈溢出，系统输出的异常是Segmentation fault（当然不是所有的Segmentation fault 都是栈溢出导致的） ，如果你使用了递归，就要想一想是不是无限递归了，那么系统调用栈就会溢出。
而且在企业项目开发中，尽量不要使用递归！

public static string RemoveDuplicates(string s)
        {
            Stack<char> stack = new Stack<char>();
            for (int i = 0; i < s.Length; i++)
            {
                if (stack.Count == 0 || stack.Peek() != s[i])
                {
                    stack.Push(s[i]);
                    continue;
                }
                if (stack.Count > 0 && stack.Peek() == s[i])
                {
                    stack.Pop();
                    continue;
                }
            }
            List<char> result = new List<char>();
            while (stack.Count != 0)
            {
                result.Add(stack.Pop());
            }
            result.Reverse();
            return new string(result.ToArray());
        }

150. 逆波兰表达式求值

思路:
可以保证给定的逆波兰表达式总是有效的。换句话说，表达式总会得出有效数值且不存在除数为 0 的情况。这道题相对简单，有了这个保证，当操作符来时，栈里肯定保证至少有两个元素。

public static int EvalRPN(string[] tokens)
        {
            Stack<int> stack = new Stack<int>();
            for (int i = 0; i < tokens.Length; i++)
            {
                if (int.TryParse(tokens[i], out int result))
                {
                    stack.Push(result);
                    continue;
                }
                int right = stack.Pop();
                int left = stack.Pop();
                switch (tokens[i])
                {
                    case "+":
                        stack.Push(left + right);
                        break;
                    case "-":
                        stack.Push(left - right);
                        break;
                    case "*":
                        stack.Push(left * right);
                        break;
                    case "/":
                        stack.Push(left / right);
                        break;
                }
            
            }
            return stack.Peek();
        }