Java 平衡圆括号问题的优化解法

给定仅包含字符

（“

，

）”

，

“{'

，

'}'

，

”['

和

']

的字符串，确定输入字符串是否有效

输入字符串在以下情况下有效：

开放式括号必须由相同类型的括号封闭

必须按照正确的顺序关闭开放式支架

请注意，空字符串也被认为是有效的

例1：

Input: "()[]{}"
Output: true
Example 2:

例2：

Input: "{[(])}"
Output: false

我对上述问题的解决方案是：

static boolean isPair(char left,char right){
        return left=='{' && right=='}' || left=='(' && right==')' || left=='[' && right==']'; 
    }
    public boolean isValid(String s) {
        Stack<Character> stack= new Stack<>();
        for(char ch: s.toCharArray()){
            if(ch=='(' || ch=='{' || ch=='['){
                stack.push(ch);
            }
            else{
                if(!stack.isEmpty() && isPair(stack.peek(),ch))
                    stack.pop();
                else
                    return false;
            }
        }
        return stack.isEmpty();
}

静态布尔值isPair（左字符、右字符）{
返回left='{'&&right='}'| | left='（'&&right='）'| | | left='['&&right=']；
}
公共布尔值无效（字符串s）{
堆栈=新堆栈（）；
for（char ch:s.toCharArray（））{
如果（ch='（'| | ch='{'| | ch=='['））{
堆栈推送（ch）；
}
否则{
if（！stack.isEmpty（）&&isPair（stack.peek（），ch））
stack.pop（）；
其他的
返回false；
}
}
返回stack.isEmpty（）；
}

我在某处找到了一个更聪明的解决方案，但我无法理解它。 代码如下：

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

公共布尔值有效（字符串s）{
堆栈=新堆栈（）；
for（char ch:s.toCharArray（））{
如果（ch=='（'）
堆栈推送（'）；
else如果（ch='{'）
stack.push（'}'）；
else if（ch='['）
stack.push（']'）；
else if（stack.isEmpty（）| | stack.pop（）！=ch）
返回false；
}
返回stack.isEmpty（）；
}

---

请帮助我了解最后一个

的工作原理，否则如果

块。

您已经为所有的

开始

括号推了

结束括号。因此，当结束括号出现时，它将匹配堆栈顶部的字符。如果不匹配或堆栈变为空。这意味着不平衡

else if(stack.isEmpty() || stack.pop()!=ch)
    return false;

当您到达此处时，您有一个
括号
作为ch，但堆栈为空或堆栈中的值与传入字符不匹配

因此，偏执论是不平衡的，它实际上与你自己的版本非常相似

else if(stack.isEmpty() || stack.pop()!=ch)
    return false;

主要区别在于将开放括号推到堆栈中，并在
isPair
中检查堆栈顶部的开放括号是否与当前正在计算的结束括号匹配

该解决方案通过直接将预期的结束括号推到堆栈来跳过它，但功能上是相同的

最后的
if-else
与您的
else
完全相同：

如果
stack.isEmpty（）
返回false
如果不为空且与堆栈顶部的括号不匹配，则返回false
否则会弹出顶部的支架
对于案例2，该解决方案会弹出堆栈，而在您的解决方案中不会弹出堆栈。但是，当函数返回时，它不会更改任何内容，并且该堆栈将不再使用。
您的堆栈包含未闭合的括号。第二个示例中的堆栈包含预期的括号。最后一个
如果
just测试当前字符是否为预期括号。为什么您认为此解决方案是“优化的”？它是为什么而优化的？我之所以称它为优化是因为内存使用量……我的代码的内存使用量是34.4MB，而在
LeetCode平台上的这个解决方案是34.2MB。如果使用
StringBuilder
（追加/删除）而不是
堆栈
（推送/弹出），您可能会使用更少的内存，因为可以避免使用自动装箱的值。另外：使用索引for循环和
s.charAt（i）
比
tocharray（）
更好，因为后者复制字符串的字符数组。