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

LeetCode 20.有效的括号
题目链接：20. 有效的括号 - 力扣（LeetCode）

​思路：

搞一个字典，匹配一下，用栈来实现就好。如果和栈顶不匹配return false，到最后如何栈为空说明都匹配了return true。

#python
match = {')':'(','}':'{',']':'['}
class Solution:
    def isValid(self, s: str) -> bool:
        s = list(s)
        stack = []
        for x in s:
            if x in ['{','[','(']:
                stack.append(x)
            else:
                if not stack or match[x] != stack[-1]:
                    return False
                else:
                    stack.pop()
        return True if len(stack) == 0 else False

#java
import java.util.ArrayDeque;  
import java.util.Deque;  
import java.util.HashMap;  
import java.util.Map;  
  
class Solution {  
    public boolean isValid(String s) {  
        Deque<Character> deque = new ArrayDeque<>();  
        Map<Character, Character> map = new HashMap<>();  
        map.put('{', '}');  
        map.put('(', ')');  
        map.put('[', ']');  
  
        for (char c : s.toCharArray()) { // 使用for-each循环简化代码  
            if (map.containsKey(c)) {  
                // 如果当前字符是左括号，将其添加到栈中  
                deque.offerLast(c);  
            } else if (!deque.isEmpty() && map.get(deque.peekLast()) == c) {  
                // 如果栈不为空且栈顶左括号的对应右括号与当前字符匹配，则出栈  
                deque.pollLast();  
            } else {  
                // 如果当前字符不是右括号或栈为空或栈顶元素与当前字符不匹配，返回false  
                return false;  
            }  
        }  
        // 如果栈为空，说明所有括号都正确匹配  
        return deque.isEmpty();  
    }  
}

困难与想法：

当stackB不为空的时候，peek的时候一定要先看stackB啊，优先级高于stackA，因为栈实现队列，是两个栈反复，最后要先作用于最后一个栈stackB的。

---

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

题目链接：1047. 删除字符串中的所有相邻重复项 - 力扣（LeetCode）

​
思路：

队列是右进左出，栈是右进右出，那我们就把队列A的除去右边元素的左边全部添加至队列B中，然后把队列A最后一个给peek或者pop就ok，注意的是这个过程中要注意交换一下队列A和队列B，判断是不是空的也很简单，就判断A就好了，因为B肯定是空的

代码：

#python
class MyStack:

    def __init__(self):
        self.A,self.B=deque(),deque()

    def push(self, x: int) -> None:
        self.A.append(x)

    def pop(self) -> int:
        if self.empty():
            return None
        for i in range(len(self.A) - 1):
            self.B.append(self.A.popleft())
        self.A,self.B=self.B,self.A
        return self.B.popleft()

    def top(self) -> int:
        if self.empty():
            return None
        for i in range(len(self.A) - 1):
            self.B.append(self.A.popleft())
        self.A,self.B=self.B,self.A
        tmp=self.B.popleft()
        self.A.append(tmp)
        return tmp

    def empty(self) -> bool:
        return len(self.A)==0

# Your MyStack object will be instantiated and called as such:
# obj = MyStack()
# obj.push(x)
# param_2 = obj.pop()
# param_3 = obj.top()
# param_4 = obj.empty()

#java
class Solution {
    public String removeDuplicates(String s) {
        Deque<Character> deque = new ArrayDeque<>();
        for(char ch : s.toCharArray()){
            if(deque.isEmpty() || deque.peekLast() != ch){
                deque.offerLast(ch);
            }
            else{
                deque.pollLast();
            }
        }
        StringBuilder sb = new StringBuilder();
        for(char ch : deque){
            sb.append(ch);
        }
        return sb.toString();
    }
}

困难与想法：

关键在于peek与pop，peek的话还要记住把元素返回到队列A中去啊。

---

LeetCode 150逆波兰表达式求值

题目链接：150. 逆波兰表达式求值 - 力扣（LeetCode）

​
思路：

注意判断一下操作符，讨论一下各种情况，

代码：

#python
class Solution:
    def evalRPN(self, tokens: List[str]) -> int:
        stack = []
        for x in tokens:
            if x.isdigit() or (x[0] == '-' and x[1:].isdigit()):
                stack.append(int(x))
            else:
                b = stack.pop()
                a = stack.pop()
                if x == '+':
                    stack.append(a + b)
                elif x == '-':
                    stack.append(a - b)
                elif x == '*':
                    stack.append(a * b)
                elif x == '/':
                    stack.append(int(a / b))
        return stack[0]

#java
import java.util.Stack;

class Solution {
    public int evalRPN(String[] tokens) {
        Stack<Integer> stack = new Stack<>();

        for (String token : tokens) {
            if (isOperator(token)) {
                // 弹出栈顶的两个操作数
                int operand2 = stack.pop();
                int operand1 = stack.pop();
                int result = applyOperation(token.charAt(0), operand1, operand2);
                stack.push(result);
            } else {
                // 如果是操作数，直接压入栈
                stack.push(Integer.parseInt(token));
            }
        }

        // 返回栈中的唯一元素，即表达式的结果
        return stack.pop();
    }

    private boolean isOperator(String token) {
        return token.equals("+") || token.equals("-") || token.equals("*") || token.equals("/");
    }

    private int applyOperation(char operator, int operand1, int operand2) {
        switch (operator) {
            case '+': return operand1 + operand2;
            case '-': return operand1 - operand2;
            case '*': return operand1 * operand2;
            case '/': return operand1 / operand2; // 向零截断
            default: throw new IllegalArgumentException("Invalid operator: " + operator);
        }
    }
}

困难与想法：

每次操作的时候要从栈里面推出两个元素来操作，再把答案push入栈。