LeetCode 20. 有效的括号

心路历程

拿到题最开始的思路不太正确，想使用指针i，查看i的下一位或尾部的那位是否匹配

class Solution {
    public boolean isValid(String s) {
        char[] s_char = s.toCharArray();
        if(s_char.length==0){
            return true;
        }
        else if(s_char.length==1){
            return false;
        }
        int i = 0;
        int k = s_char.length-1;
        while (i<s_char.length){
            char opp = opposite(s_char[i]);
            if(opp==0) return false;
            int j = i + 1;
            if(s_char[j]!=opp&&s_char[k]!=opp){
                return false;
            }
            else if(s_char[k]==opp){
                k--;
                if(k==i){
                    break;
                }
                else i++;
            }
            else {
                i = i+2;
            }
        }
        return true;
    }

    public char opposite(char symbol){
        switch (symbol){
            case '(': return ')';
            case '[': return ']';
            case '{': return '}';
        }
        return 0;
    }
}

忽略了这种输入情况

失败后立马换思路，想到了栈
指针i遍历char数组，m记录i指针指向那一位所对应的括号，若s_char[i] == m，则出队，否则继续入队

class Solution {
    public boolean isValid(String s) {
        char[] s_char = s.toCharArray();
        if(s_char.length==0){
            return true;
        }
        Stack<Character> stack = new Stack<Character>();
        char m = opposite(s_char[0]);
        if(m==0){
            return false;
        }
        stack.push(s_char[0]);
        int i = 1;
        while(i<s_char.length){
            if(s_char[i]==m){
                stack.pop();
                if(!stack.isEmpty()) {
                    m = opposite(stack.peek());
                }
                else m = 0;
            }
            else {
                stack.push(s_char[i]);
                m = opposite(s_char[i]);
                if(m==0){
                    return false;
                }
            }
            i++;
        }
        if(stack.isEmpty()){
            return true;
        }
        else {
            return false;
        }

    }

    public char opposite(char symbol){
        switch (symbol){
            case '(': return ')';
            case '[': return ']';
            case '{': return '}';
        }
        return 0;
    }
}

结果还过得去

大佬解法

查看了下评论区大佬的解法：
大佬的思路是不把i存入栈中，直接把所要的m存进去，下一次直接出栈比较就完事
是我的算法的简化版

一开始没看懂，主要是这一行

拆分一下，逻辑清晰很多

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