Amber-Leedcode-Java-代码随想录打卡第十一天 ｜ ● 20. 有效的括号● 1047. 删除字符串中的所有相邻重复项● 150. 逆波兰表达式求值

● 20. 有效的括号

1.初识

不得不说和本科时候学的汇编异曲同工

{()}这样有效吗？（有效）

• 输入: "{[]}"
• 输出: true

2.注意点

for (char ch : s.toCharArray())是啥？

for (char ch : s.toCharArray())

3.代码逻辑

如果出现（ { [ 这样的字符，就把其对应的匹配符号加入栈，如果后续遇到了} ] ) 这样在右侧的匹配符号，就依次消掉，直到末尾。如果期间匹配符号消不掉，或者最后栈里有剩余，就false。代码随想录里面的解释很好。。

与自己的相比，自己的明显太复杂了。。。

代码随想录code

class Solution {
    public boolean isValid(String s) {
        Deque<Character> deque = new LinkedList<>();
        char ch;
        for (int i = 0; i < s.length(); i++) {
            ch = s.charAt(i);
            //碰到左括号，就把相应的右括号入栈
            if (ch == '(') {
                deque.push(')');
            }else if (ch == '{') {
                deque.push('}');
            }else if (ch == '[') {
                deque.push(']');
            } else if (deque.isEmpty() || deque.peek() != ch) {
                return false;
            }else {//如果是右括号判断是否和栈顶元素匹配
                deque.pop();
            }
        }
        //最后判断栈中元素是否匹配
        return deque.isEmpty();
    }
}

4.Code

虽然是自己写出来的，但感觉太复杂了，肯定不优，又去看的课程。。。

主要思路是：先在把string转stack的时候判断是否存在相邻的对称符号，如果有，就先删掉。在后面的循环里再判断是否有间隔的对称符号，把原先的stack一分为二，另一半放入另一个stack中，分别放到两个stack中，分别取peak的元素，如果一直都相匹配，就true。

class Solution {
    public boolean isValid(String s) {

        Stack<Character> stack_one = new Stack<>();
        Stack<Character> stack_two = new Stack<>();

        int size = s.length();
        if (size%2 == 1){
            return false;
        }
        char tmp = 'a';
        boolean flag = false;
        int new_size = 0;
        for (char ch : s.toCharArray()) {
            if (tmp == '(' && ch == ')'){
                stack_one.pop();
                new_size--;
                if (stack_one.isEmpty() == false){
                    tmp = stack_one.peek();
                }else{
                    tmp = 'a';
                }
            }else if(tmp == '{' && ch == '}'){
                stack_one.pop();
                new_size--;
                if (stack_one.isEmpty() == false){
                    tmp = stack_one.peek();
                }else{
                    tmp = 'a';
                }
            }else if (tmp == '[' && ch == ']'){
                stack_one.pop();
                new_size--;
                if (stack_one.isEmpty() == false){
                    tmp = stack_one.peek();
                }else{
                    tmp = 'a';
                }
            }else{
                tmp = ch;
                stack_one.push(ch);
                flag = true;
                new_size++;
            }
        }
        size = new_size/2;
        if (flag == true){
             for(int i = 0;i<size;i++){
            char tmps = stack_one.pop();
            stack_two.push(tmps);
        }
        }

        while(stack_one.isEmpty() == false){
            if (stack_one.peek() == '(' &&  stack_two.peek() == ')'){
                stack_one.pop();
                stack_two.pop();
                continue;
            }else if (stack_one.peek() == '{' &&  stack_two.peek() == '}'){
                   stack_one.pop();
                   stack_two.pop();
                  continue;
            }else if (stack_one.peek() == '[' &&  stack_two.peek() == ']'){
                   stack_one.pop();
                   stack_two.pop();
                   continue;
            }else{
                return false;
            }
        }
        return true;

    }
}

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

1.初识

待更

和上一题思路类似吧

别人的代码

什么是推栈？？？

class Solution {
    public String removeDuplicates(String S) {
        //ArrayDeque会比LinkedList在除了删除元素这一点外会快一点
        //参考：https://stackoverflow.com/questions/6163166/why-is-arraydeque-better-than-linkedlist
        ArrayDeque<Character> deque = new ArrayDeque<>();
        char ch;
        for (int i = 0; i < S.length(); i++) {
            ch = S.charAt(i);
            if (deque.isEmpty() || deque.peek() != ch) {
                deque.push(ch);
            } else {
                deque.pop();
            }
        }
        String str = "";
        //剩余的元素即为不重复的元素
        while (!deque.isEmpty()) {
            str = deque.pop() + str;
        }
        return str;
    }
}

题外话来自代码随想录

code

虽然是自己写出来的，但在最后栈转string的时候遇到了问题，类型转换可真麻烦啊。。。

class Solution {
    public String removeDuplicates(String s) {

        Stack<Character> stack = new Stack<>();

        for(int i = 0;i < s.length();i++){

            if (stack.isEmpty() == false && stack.peek() == s.charAt(i)){
                stack.pop();
            }else{
                stack.push(s.charAt(i));
            }
        }
         StringBuilder stringBuilder = new StringBuilder();
        while (!stack.isEmpty()) {
            // 从栈中弹出字符并添加到StringBuilder中
            stringBuilder.append(stack.pop());
        }

        // 将StringBuilder反转，因为栈是LIFO的，我们需要反转来恢复原始顺序
        String result = stringBuilder.reverse().toString();

        return result;


}
}

● 150. 逆波兰表达式求值

待更

OMG 终于写出来了，我只能说自己对于string和char的理解太不到位了，代码逻辑没有bug，问题全出在了如何写正确的代码上，吐了。。。。

class Solution {
    public boolean isNumeric(String str) {
    char[] chars = str.toCharArray();

    // 检查第一个字符是否为负号或数字
    if (!Character.isDigit(chars[0]) && chars[0] != '-') {
        return false;
    }else if (chars[0] == '-' && chars.length == 1){
        return false;
    }

    // 从第二个字符开始，每个字符都必须是数字
    for (int i = 1; i < chars.length; i++) {
        if (!Character.isDigit(chars[i])) {
            return false;
        }
    }
    return true;
}


    public int evalRPN(String[] tokens) {

        Stack<String> stack = new Stack<String>();
        int i = 0;
        int sum = 0;
        if (tokens.length == 1){
            return Integer.parseInt(tokens[0]);
        }
        while (i < tokens.length){
            String str = tokens[i];
            boolean isNumeric = isNumeric(str);
            char ch = str.charAt(0);
            if (isNumeric == true){
                stack.push(str);
            }else{
                int one = Integer.parseInt(stack.pop());
                int two = Integer.parseInt(stack.pop());
                if (ch == '+'){
                    sum = one + two;
                }else if (ch == '-'){
                    sum = two - one ;
                }else if (ch == '/'){
                    sum = two / one ;
                }else if (ch == '*'){
                    sum = one * two;
                }
                String str1 = String.valueOf(sum);
                stack.push(str1);
            }
            i++;
        }
        return sum;
    }
}

总结：

1. 状态：未完结
2. 学习1。5小时左右
3. 困难：凑合
4. 待解决问题：。。
5. 今日收获：栈的妙用
6. 来源： 代码随想录