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

20. 有效的括号

链接：力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

细节：

1. 思路是：这道题必须是左右一一对应（左边无论出现多少，右边就要出现多少），如果不行（左多 / 右多 / 类型问题），那就是false

 

class Solution {
    public boolean isValid(String s) {
         Stack<Character> stack  = new Stack<>();
        for (char c : s.toCharArray()){
            if (c == '(' || c == '[' || c == '{'){
                stack.push(c);
            }
            else if (c == ')' && !stack.isEmpty() && stack.peek() == '('){
                stack.pop();
            }
            else if (c == ']' && !stack.isEmpty() && stack.peek() == '['){
                stack.pop();
            }
            else if (c == '}' && !stack.isEmpty() && stack.peek() == '{'){
                stack.pop();
            }
            else{
                return false;
            }

        }
        return stack.isEmpty();
    }
}

class Solution {
    public boolean isValid(String s) {
 
        Stack<Character> stack = new Stack<>();
 
 
        // 剪枝操作
        if (s.length() % 2 != 0) {
            return false;
        }
 
        // 遍历字符串
        for (int i = 0; i < s.length(); i++) {
            char ch = s.charAt(i);
            if (ch == '(') {
                stack.push(')');
            } else if (ch == '[') {
                stack.push(']');
            } else if (ch == '{') {
                stack.push('}');
            } else if (ch == ')' || ch ==']' || ch =='}') {
                if (!stack.isEmpty() && stack.peek().equals(ch) ) {
                    stack.pop();
                } else {
                    return false;
                }
            } 
        }
 
        return stack.isEmpty();
    }
}

 

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

链接：力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

细节：

两种思路，一个是栈，一个是用字符串模拟栈

定义一个栈

        如果因为压栈再弹栈和顺序会变化，所以最后要使用reverse()，如果不想反转可以从后往前遍历字符串

class Solution {
    public String removeDuplicates(String s) {
        Stack<Character> stack = new Stack<>();
        StringBuilder sb = new StringBuilder();
 
        for (int i = 0; i < s.length(); i++) {
            if (!stack.isEmpty() && stack.peek().equals(s.charAt(i))) {
                stack.pop();
            } else {
                stack.push(s.charAt(i));
            }
        }
 
        while (!stack.isEmpty()) {
            sb.append(stack.pop());
        }
 
 
        return sb.reverse().toString();
    }
}

 字符串作为栈

        字符串sb作为栈，从字符串s的头开始添加字符，sb的最后一个字符就是栈顶元素，每次添加的时候直接进行比较，如果不相等就添加，如果相等，就删除最后一个字符

class Solution {
    public String removeDuplicates(String s) {
        StringBuffer res = new StringBuffer();
        int top = -1;
        for (int i = 0; i < s.length(); i++){
            char c = s.charAt(i);
            if (top >= 0 && res.charAt(top) == c){
                res.deleteCharAt(top);
                top--;
            }
            else{
                res.append(c);
                top++;
            }
        }
        return res.toString();
    }
}

class Solution {
    public String removeDuplicates(String s) {
        StringBuilder sb = new StringBuilder();
 
        for (int i = 0; i < s.length(); i++) {
            char ch = s.charAt(i);
            int top = sb.length() - 1;
            if (sb.length() != 0 && sb.charAt(top) == ch) {
                sb.deleteCharAt(top);
 
            } else {
                sb.append(ch);
            }
        }
 
        return sb.toString();
    }
}

 

150. 逆波兰表达式求值

链接：力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

细节：变相二叉树的后序遍历

class Solution {
    public int evalRPN(String[] tokens) {
        Deque<Integer> stack = new LinkedList();
        for (String s : tokens) {
            if ("+".equals(s)) {        // leetcode 内置jdk的问题，不能使用==判断字符串是否相等
                stack.push(stack.pop() + stack.pop());      // 注意 - 和/ 需要特殊处理
            } else if ("-".equals(s)) {
                stack.push(-stack.pop() + stack.pop());
            } else if ("*".equals(s)) {
                stack.push(stack.pop() * stack.pop());
            } else if ("/".equals(s)) {
                int temp1 = stack.pop();
                int temp2 = stack.pop();
                stack.push(temp2 / temp1);
            } else {
                stack.push(Integer.valueOf(s));//遇见数字就加入栈里
            }
        }
        return stack.pop();
    }
}