算法学习 day11

20.有效的括号

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

有效字符串需满足：

1. 左括号必须用相同类型的右括号闭合。
2. 左括号必须以正确的顺序闭合。
3. 每个右括号都有一个对应的相同类型的左括号。

示例 1：

输入：s = "()"
输出：true
示例 2：

输入：s = "()[]{}"
输出：true
示例 3：

输入：s = "(]"
输出：false

输入：s = "([{}])"
输出：true

思考

• 成对出现的符号，用栈存储“另一半”，栈顶元素一定是和当前元素相同，主要是结合栈结构和符号的规律技巧
• “消消乐”思想

复杂度

• 时间 O(n)
• 空间 O(n)

import java.util.Stack;

//leetcode submit region begin(Prohibit modification and deletion)
class Solution {
    public boolean isValid(String s) {
        Stack<Character> st = new Stack<Character>();
        char[] cs = s.toCharArray();
        for (int i = 0; i < cs.length; i++) {
            char cur = cs[i];
            if(!st.empty()){
                char top = st.peek();
                if((cur == ')' && top == '(')
                        ||(cur == ']' && top == '[')
                        ||(cur == '}' && top == '{'))
                {
                    st.pop();
                    continue;
                }
            }
            st.push(cs[i]);
        }

        return st.empty() ;
    }
}

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

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

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

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

示例：

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

思路

• “消消乐”思想，用栈存储已经遍历过的字符，下一个字符与栈顶比较，相同的话“抵消”，出栈

复杂度

• 时间 O(n)
• 空间 O(n)

import java.util.Stack;

//leetcode submit region begin(Prohibit modification and deletion)
class Solution {
    public String removeDuplicates(String s) {
        if(s.length() == 1) return s;
        Stack<Character> stack = new Stack<>();
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if (!stack.isEmpty() && c == stack.peek()) {
                stack.pop();
            }else{
                stack.push(c);
            }
        }
        char[] strs = new char[stack.size()];
        int idx = stack.size() -1 ;
        while (!stack.isEmpty()) {
            strs[idx] = stack.pop();
            idx -- ;
        }
        return new String(strs);
    }
}

//直接使用revers()函数反正字符结果
class Solution {
    public String removeDuplicates(String s) {
        Deque<Character>  st = new LinkedList<Character>();
        for (int i = 0; i < s.length(); i++) {
            if (!st.isEmpty() && st.peek() == s.charAt(i)) {
                st.poll();
            } else {
                st.push(s.charAt(i));
            }

        }
        StringBuilder sb = new StringBuilder();
        while(!st.isEmpty()) {
            sb.append(st.poll());
        }
        return sb.reverse().toString();
    }
}

150. 逆波兰表达式求值

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

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

  注意 两个整数之间的除法只保留整数部分。

  可以保证给定的逆波兰表达式总是有效的。换句话说，表达式总会得出有效数值且不存在除数为 0 的情况。

示例 1：

输入：tokens = ["2","1","+","3","*"]
输出：9
解释：该算式转化为常见的中缀算术表达式为：((2 + 1) * 3) = 9
示例 2：

输入：tokens = ["4","13","5","/","+"]
输出：6
解释：该算式转化为常见的中缀算术表达式为：(4 + (13 / 5)) = 6
示例 3：

输入：tokens = ["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

思路

• 逆波兰表达式经典解法：栈
• 难点在于如何构造栈：将每次计算结果重新入栈（核心点）
• 细节：计算式栈顶元素为被计算数，倒数第二个元素为计算数（在运算符前面）

复杂度

• 时间 O(n)
• 空间 O(n)

import java.util.Stack;

//leetcode submit region begin(Prohibit modification and deletion)
class Solution {
    public int evalRPN(String[] tokens) {
        Stack<Integer> stack = new Stack<>();
        for (String str : tokens) {
            Integer top = 0 ;
            switch (str) {
                case "+":
                    top = stack.pop();
                    stack.push(stack.pop() + top);
                    break;
                case "-":
                    top = stack.pop();
                    stack.push(stack.pop() - top);
                    break;
                case "*":
                    top = stack.pop();
                    stack.push(stack.pop() * top);
                    break;
                case "/":
                    top = stack.pop();
                    stack.push(stack.pop() / top);
                    break;
                default:
                    stack.push(Integer.parseInt(str));
                    break;
            }
        }
        return stack.pop();
    }
}

使用deque实现

class Solution {
    public int evalRPN(String[] tokens) {
        Deque<Integer> st = new LinkedList<Integer>();
        for (int i = 0; i < tokens.length; i++) {
            Integer top = 1 ;
            switch (tokens[i]) {
                case "+":
                    top = st.pop();
                    st.push(st.pop() +top);
                    break;
                case "-":
                    top = st.pop();
                    st.push(st.pop() - top);
                    break;
                case "*":
                    top = st.pop();
                    st.push(st.pop() * top);
                    break;
                case "/":
                    top = st.pop();
                    st.push(st.pop() / top);
                    break;
                default:
                    st.push(Integer.parseInt(tokens[i]));
                    break;
            }
        }
        return  st.pop();
    }
}

总结

• “消消乐”思想，可用栈存储待“消除”的符号，难点在于找到栈初始化的规律，技巧在于多画图分析