LeetCode刷题之旅（简单-6）：有效的括号

关注

原创最新推荐文章于 2026-08-01 10:20:21 发布 314 阅读 AI 写同款· GEO 优化 ›

力扣第二十题-有效的括号前言力扣第二十题有效的括号如下所示：给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。有效字符串需满足：左括号必须用相同类型的右括号闭合。左括号必须以正确的顺序闭合。示例 1：输入：s = “()” 输出：true 示例 2：输入：s = “()[]{}” 输出：true 示例 3：输入：s = “(]” 输出：false 一、思路看到这种一一对应匹配的问题，我第一反应就是想到用栈来实现。因为栈的数据结构是先进后出阅读详情

2019年5月6日

题目：有效的括号

解决方法一：正向思维，栈顶元素与字符串下一字符进行比较

性能结果：

思路：

解决方法二：逆向思维，把匹配元素入栈，顺序弹出时发现跟字符不一致则false

题目：有效的括号

解决方法一：正向思维，栈顶元素与字符串下一字符进行比较


public class EffectiveParentheses {
    public static boolean isValid(String s) {
        boolean result = false;

        // 1.判断是否有效字符串
        if (s != null && (s.length() % 2) == 0){

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

            char[] chars = s.toCharArray();

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

                // 2.栈空，或栈顶元素跟当前元素不匹配，进栈
                if (stack.isEmpty() || !isMatch(stack.peek(),chars[i])){
                    stack.push(chars[i]);
                }else {
                // 3.栈顶元素跟当前元素匹配，出栈
                    stack.pop();
                }
            }
            result = stack.isEmpty();
        }

        return result;
    }

    private static boolean isMatch(char a ,char b) {
        switch (a){
            case '(':
                if (b == ')'){
                    return true;
                }
                else{
                    return false;
                }
            case '{':
                if (b == '}'){
                    return true;
                }
                else{
                    return false;
                }
            case '[':
                if (b == ']'){
                    return true;
                }
                else{
                    return false;
                }
            default:
                    return false;
        }
    }

    public static void main(String[] args){
//        String var = "()";
//        String var = "()[]{}";
//        String var = "(]";
//        String var = "([)]";
        String var = "{[]}";
        boolean valid = isValid(var);
        System.out.println("result= "+valid);
    }
}

性能结果：

思路：

实现的过程中需要使用到stack（栈），栈有别于arraylist等，新添加一个数便将该数存在栈的顶端。
对于这种前后匹配的问题，脑袋里第一个想法就是使用栈来实现。
java中栈的函数：

Stack stack=new Stack();可以实现泛型形式

stack.push();向栈中添加数据

stack.peek();栈的顶部的数据

stack.isEmpty();

解决方法二：逆向思维，把匹配元素入栈，顺序弹出时发现跟字符不一致则false

public static boolean isValid(String s) {
		if (s.isEmpty())
            return true;
        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() || stack.pop() != c)
                return false;
        }
        return stack.isEmpty();
    }

性能结果：

解决方法三：map把键值存储，逐个弹出；

public boolean isValid(String s) {
         if(s == null ||s.length() ==1){
            return false;
        }

        Map<Character,Character> map = new HashMap<>();
        map.put('(',')');
        map.put('[',']');
        map.put('{','}');

        char[] chars = s.toCharArray();
        char[] temp = new char[chars.length/2+1];
        int index = -1;
        for (int i = 0; i < chars.length; i++) {
            if(index>=(chars.length+1)/2){
                return false;
            }
            if(index == -1){
                if(map.get(chars[i]) == null){
                    return false;
                }
                index ++;
                temp[index] = chars[i];
                continue;
            }
            char value = temp[index];
            if(map.get(value) == chars[i]){
                index --;
            }else{
                if(map.get(chars[i]) == null){
                    return false;
                }
                index ++;
                temp[index] = chars[i];
            }
        }
        return index<0;
    }