day11 150. 逆波兰表达式求值&&1047. 删除字符串中的所有相邻重复项&&20. 有效的括号

1. 逆波兰表达式求值（150. Evaluate Reverse Polish Notation）
   功能
   计算逆波兰表达式（后缀表达式）的值。逆波兰表达式是一种数学表达式，其中每个运算符位于其操作数之后。
   实现思路
   使用数组模拟栈：
   遍历输入的字符串数组 tokens。
   如果遇到数字，将其压入栈中。
   如果遇到运算符，从栈中弹出两个数字，进行运算，并将结果压回栈中。
   最终，栈顶的数字即为表达式的值。
   代码结构
   使用 int[] nums 数组模拟栈。
   使用 top 指针表示栈顶位置。
   使用 switch 语句处理运算符和数字。
   最后返回 nums[top]。
   优化点
   使用数组模拟栈比直接使用 Stack 类更高效，因为避免了对象的创建和销毁。
   代码逻辑清晰，易于理解和维护。
   //150. 逆波兰表达式求值
   public int evalRPN(String[] tokens) {
   //模拟栈实现
   int[] nums = new int[tokens.length];
   int top=-1;
   for (String s : tokens) {
   switch (s) {
   case "+" -> {
   int a = nums[top--];
   int b = nums[top--];
   nums[++top] = b + a;
   }
   case "-" -> {
   int a = nums[top--];
   int b = nums[top--];
   nums[++top] = b - a;
   }
   case "*" -> {
   int a = nums[top--];
   int b = nums[top--];
   nums[++top] = b * a;
   }
   case "/" -> {
   int a = nums[top--];
   int b = nums[top--];
   nums[++top] = b / a;
   }
   default -> nums[++top] = Integer.parseInt(s);
   }
   }
   return nums[top];
   }

2. 删除字符串中的所有相邻重复项（1047. Remove All Adjacent Duplicates In String）
   功能
   删除字符串中所有相邻的重复字符，直到无法继续删除为止。
   实现思路
   使用数组模拟栈：
   遍历字符串的字符数组。
   如果当前字符与栈顶字符不同，将其压入栈中。
   如果当前字符与栈顶字符相同，弹出栈顶字符。
   最终，栈中剩余的字符即为结果。
   代码结构
   使用 char[] arr 存储输入字符串的字符。
   使用 top 指针表示栈顶位置。
   遍历字符数组，根据条件更新 top。
   最后通过 new String(arr, 0, top + 1) 返回结果。
   优化点
   使用数组模拟栈比直接使用 Stack 类更高效。
   避免了额外的 StringBuilder，直接通过数组操作完成，效率更高。
   //1047. 删除字符串中的所有相邻重复项
   public String removeDuplicates(String s) {
   //使用栈实现，效率不高
   /if (s == null || s.isEmpty()) {
   return s;
   }
   Stack stack = new Stack<>();
   char[] chars = s.toCharArray();
   for (char aChar : chars) {
   if (stack.isEmpty() || aChar != stack.peek()) {
   stack.push(aChar);
   } else if (aChar == stack.peek()) {
   stack.pop();
   }
   }
   StringBuilder sb = new StringBuilder();
   while (!stack.isEmpty()) {
   sb.append(stack.pop());
   }
   return sb.reverse().toString();/
   //模拟栈实现
   char[] arr=s.toCharArray();
   int top=-1;//指向栈顶
   for(int i=0;i<arr.length;i++){
   if(top==-1||arr[top]!=arr[i])
   arr[++top]=arr[i];
   else top--;
   }
   //return String.valueOf(arr,0,top+1);//效率一样
   return new String(arr,0,top+1);
   }

3. 有效的括号（20. Valid Parentheses）
   功能
   判断一个字符串中的括号是否有效。有效括号字符串必须满足：
   每个左括号必须有对应的右括号。
   括号的顺序必须正确。
   实现思路
   使用栈来处理括号匹配：
   遍历字符串的字符数组。
   如果遇到左括号，将其对应的右括号压入栈中。
   如果遇到右括号，检查栈顶是否匹配，如果不匹配或栈为空，则返回 false。
   最后，如果栈为空，则说明所有括号都正确匹配。
   代码结构
   使用 Stack 来存储右括号。
   使用 switch 语句处理左括号和右括号。
   最后检查栈是否为空。
   优化点
   使用栈是解决括号匹配问题的经典方法，逻辑清晰。
   代码中使用了 switch 语句，使得逻辑更加简洁。
   //20. 有效的括号
   public boolean isValid(String s) {
   Stack stack = new Stack<>();
   for (char c : s.toCharArray()) {
   switch (c) {
   case '('-> stack.push(')');
   case '{' -> stack.push('}');
   case '[' -> stack.push(']');
   default -> {
   if (stack.isEmpty()) return false;
   if(stack.pop()!=c)return false;
   }
   }
   }
   return stack.isEmpty();
   }
   }