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

本文链接：https://blog.youkuaiyun.com/m0_37767445/article/details/135421550

文章介绍了如何使用栈数据结构解决三个编程问题：判断有效括号、删除字符串中的相邻重复字符以及计算逆波兰表达式的值。通过栈的入栈和出栈操作，实现了高效简洁的算法实现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

20. 有效的括号

public boolean isValid(String s) {
    Boolean isValid = false;
    char[] chars = s.toCharArray();
    Stack stack = new Stack();
    for (int i = 0; i < chars.length; i++) {
        if (chars[i] == ')' || chars[i] == '}' || chars[i] == ']') {
            if (stack.empty()) {
                return Boolean.FALSE;
            }
            char pop = (char) stack.pop();
            if (chars[i] == ')') {
                if (pop != '(') {
                    return Boolean.FALSE;
                } else {
                    isValid = Boolean.TRUE;
                }
            } else if (chars[i] == '}') {
                if (pop != '{') {
                    return Boolean.FALSE;
                } else {
                    isValid = Boolean.TRUE;
                }
            } else if (chars[i] == ']') {
                if (pop != '[') {
                    return Boolean.FALSE;
                } else {
                    isValid = Boolean.TRUE;
                }
            }
        } else {
            stack.push(chars[i]);
            isValid = Boolean.FALSE;
        }
    }
    return isValid&&stack.isEmpty();
}

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

public static String removeDuplicates(String s) {
    Stack<Character> stack = new Stack<>();
    Stack<Character> myStackRes = new Stack<>();
    char[] chars = s.toCharArray();
    for (int i = 0; i < chars.length; i++) {
        if (!stack.isEmpty()) {
            Character peek = stack.peek();
            if (chars[i] != peek) {
                stack.push(chars[i]);
            } else {
                stack.pop();
            }
        } else {
            stack.push(chars[i]);
        }
    }

    while (!stack.isEmpty()) {
        Character pop = stack.pop();
        if (!myStackRes.isEmpty()) {
            Character peek = myStackRes.peek();
            if (pop != peek) {
                myStackRes.push(pop);
            } else {
                myStackRes.pop();
            }
        } else {
            myStackRes.push(pop);
        }
    }

    StringBuilder sb = new StringBuilder();
    while (!myStackRes.isEmpty()) {
        Character pop = myStackRes.pop();
        sb.append(pop);
    }

    return sb.toString();
}

150. 逆波兰表达式求值

public static int evalRPN(String[] tokens) {
    if (tokens.length == 1){
        return Integer.valueOf(tokens[0]);
    }
    Integer res = 0;
    Integer one = 0;
    Integer two = 0;
    Stack<Integer> stack = new Stack<>();
    Stack<String> stack1Res = new Stack<>();
    Set<String> set = new HashSet<>();
    set.add("+");
    set.add("-");
    set.add("*");
    set.add("/");
    for (String token : tokens) {
        if (set.contains(token)) {
            if (!stack.isEmpty()) {
                one = stack.pop();
                if (!stack.isEmpty()) {
                    two = stack.pop();
                    switch (token) {
                        case "+":
                            res = two + one;
                            stack.push(res);
                            break;
                        case "-":
                            res = two - one;
                            stack.push(res);
                            break;
                        case "*":
                            res = two * one;
                            stack.push(res);
                            break;
                        case "/":
                            if (one == 0) {
                                throw new RuntimeException("被除数不能为0");
                            }
                            res = two / one;
                            stack.push(res);
                            break;
                    }

                } else {
                    switch (token) {
                        case "+":
                            res = res + one;
                            stack.push(res);
                            break;
                        case "-":
                            res = res - one;
                            stack.push(res);
                            break;
                        case "*":
                            res = res * one;
                            stack.push(res);
                            break;
                        case "/":
                            if (one == 0) {
                                throw new RuntimeException("被除数不能为0");
                            }
                            res = res / one;
                            stack.push(res);
                            break;
                    }

                }


            }

        } else {
            Integer r = Integer.valueOf(token);
            stack.push(r);
        }
    }


    return res;
}