随想录刷题笔记 —栈与队列篇2 20有效括号 1047删除字符串相邻重复项 150逆波兰表达式求值

20有效括号

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

使用栈来做括号匹配，如果是左括号则入栈，如果是右括号则出栈，在遇到右括号出栈时比较括号类型是否相同即可。

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

1047删除字符串相邻重复项

反复删除两个相邻且相同的字母

使用栈进行比较，遍历字符串的字符，如果栈空且栈顶元素与该字符不相同，则入栈，如果相同则出栈。

最后将栈内元素全部弹出后倒置。

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

优化：使用字符数组替代栈，可以减少运行时间和消耗内存。使用Top指针作为栈顶元素指针。

class Solution {
    public String removeDuplicates(String s) {
        char[] chars = s.toCharArray();
        int top = -1;
        for (int i = 0; i < s.length(); i++) {
            if (top<0||chars[top]!=s.charAt(i)){
                chars[++top] = s.charAt(i);
            }else {
                top--;
            }
        }
        return String.valueOf(chars, 0, top+1);
    }
}

150逆波兰表达式求值

逆波兰表达式是一种后缀表达式

递归处理

class Solution {
    int pos;
    public int evalRPN(String[] tokens) {
        this.pos = tokens.length-1;
        return evaluate(tokens);
    }

    public int evaluate(String[] t){
        String token = t[pos];
        pos--;
        if(token.equals("+")){
            return evaluate(t) + evaluate(t); 
        }else
        if(token.equals("*")){
            return evaluate(t) * evaluate(t);
        }else 
        if(token.equals("-")){
            return -evaluate(t) + evaluate(t);
        }else
        if(token.equals("/")){
            int right = evaluate(t);
            return evaluate(t) / right;
        }else{
            return Integer.parseInt(token);
        }
    }
}

用栈处理，数字入栈，运算符出栈两个，计算后的结果入栈

class Solution {
    public int evalRPN(String[] tokens) {
        Stack<Integer> stack = new Stack<>();
        for (int i = 0; i < tokens.length; i++) {
            if (Objects.equals(tokens[i], "+")){
                int n1 = stack.pop();
                int n2 = stack.pop();
                stack.push(n1+n2);
            } else if (Objects.equals(tokens[i], "-")) {
                int n1 = stack.pop();
                int n2 = stack.pop();
                stack.push(n2-n1);
            } else if (Objects.equals(tokens[i], "*")) {
                int n1 = stack.pop();
                int n2 = stack.pop();
                stack.push(n1*n2);
            } else if (Objects.equals(tokens[i], "/")) {
                int n1 = stack.pop();
                int n2 = stack.pop();
                stack.push(n2/n1);
            } else {
                stack.push(Integer.parseInt(tokens[i]));
            }
        }
        return stack.pop();
    }
}

优化：使用整数数组替代栈，可以减少运行时间和消耗内存。使用Top指针作为栈顶元素指针。

class Solution {
    public int evalRPN(String[] tokens) {
        int[] ints = new int[tokens.length];
        int top = -1;
        for (String token : tokens) {
            if (Objects.equals(token, "+")) {
                int n1 = ints[top - 1];
                int n2 = ints[top];
                ints[--top] = n1 + n2;
            } else if (Objects.equals(token, "-")) {
                int n1 = ints[top - 1];
                int n2 = ints[top];
                ints[--top] = n1 - n2;
            } else if (Objects.equals(token, "*")) {
                int n1 = ints[top - 1];
                int n2 = ints[top];
                ints[--top] = n1 * n2;
            } else if (Objects.equals(token, "/")) {
                int n1 = ints[top - 1];
                int n2 = ints[top];
                ints[--top] = n1 / n2;
            } else {
                ints[++top] = Integer.parseInt(token);
            }
        }
        return ints[0];
    }
}

收获

可以用栈来替代递归

可以用数组和top指针替代栈