1.题目

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

有效字符串需满足：

• 左括号必须用相同类型的右括号闭合。 左括号必须以正确的顺序闭合。

示例 1：

输入：s = "()" 输出：true

示例 2：

输入：s = "()[]{}" 输出：true

示例 3：

输入：s = "(]" 输出：false

示例 4：

输入：s = "([)]" 输出：false

示例 5：

输入：s = "{[]}" 输出：true

提示：

• 1 <= s.length <= 104
• s 仅由括号 '()[]{}' 组成

2.答题

思路1（暴力）：

• 定义3种类型的括号对：‘()’ '[]' '{}'
• 循环条件：字符串中包含3中类型之一
• 循环体：替换模板字符串

确实很暴力，代码如下：

public class Solution {
    public boolean isValid(String s) {
        while(s.contains("()") || s.contains("[]") || s.contains("{}")) {
            s = s.replace("()", "");
            s = s.replace("[]", "");
            s = s.replace("{}", "");
        }
        return s.length() == 0;
    }
}

时间复杂度

遍历一次O(n)

空间复杂度

字符串是不可变的，每次替换操作都是重新生成一个新变量，空间为3n，复杂度为O(n)

提交结果

思路2（栈）：

基于先进后出的概念，循环字符串内容，

如果是前括号，当前值入栈

• 如果栈顶的值与当前值是匹配的括号，栈顶出栈，
• 如果栈顶的值与当前值不是匹配的括号，当前值入栈，
• 循环完成后判断栈中的元素是否为空即可。

这样会是内层的括号优先匹配，如果是不能正常匹配的值，会造成栈顶元素无法出栈。

代码如下：

class Solution {
    public boolean isValid(String s) {
        Stack<Character> stack = new Stack<Character>();
        for (char c : s.toCharArray()) {
            if (stack.isEmpty()) {
                stack.push(c);
                continue;
            }
​
            char topItem = stack.peek();
            switch(c) {
                case '(':
                case '[':
                case '{':
                    stack.push(c);
                    break;
                case ')':
                    if (topItem == '(') {
                        stack.pop();
                    } else {
                        stack.push(c);
                    }
                    break;
                case ']':
                    if (topItem == '[') {
                        stack.pop();
                    } else {
                        stack.push(c);
                    }
                    break;
                case '}':
                    if (topItem == '{') {
                        stack.pop();
                    } else {
                        stack.push(c);
                    }
                    break;
            }
        }
        return stack.isEmpty();
    }
}

时间复杂度

遍历一次O(n)

空间复杂度

使用的是常量级的空间

提交结果

其实，在后括号判断的时候，第一次出现不匹配的值就可以直接返回不匹配了，因为在循环中，只是对栈顶的前括号比较，如果出现后括号，肯定只能由入栈操作了。

只要修改一下switich后括号入栈的部分

switch(c) {
    case '(':
    case '[':
    case '{':
        stack.push(c);
        break;
    case ')':
        if (topItem == '(') {
            stack.pop();
        } else {
            return false;//修改
        }
        break;
    case ']':
        if (topItem == '[') {
            stack.pop();
        } else {
            return false;//修改
        }
        break;
    case '}':
        if (topItem == '{') {
            stack.pop();
        } else {
            return false;//修改
        }
        break;
}

时间复杂度

节省了一些情况下的循环次数，平均还是O(n)

空间复杂度

使用的是常量级的空间

提交结果

后面的代码长了一些，但是节省了字符串新建的时间和空间。

如果有好的方法欢迎留言。