检查java中的有效括号

我试图找出给定的输入是否是有效的括号。输入字符串由“（”、“）”、“{”、“}”、“[”和“]”组成。
输入字符串在以下情况下有效：

1.开放式括号必须由相同类型的括号封闭。
2.开放式支架必须按正确顺序关闭。 3.空字符串是有效的

然而，我下面使用递归的代码在有效的情况下不起作用。假设它转到基本情况（当输入为“”时），但转到for循环后的return语句

class Solution {

    public boolean validParen(String input) {

        if(input.isEmpty()) {
            return true;
        }

        else {
            for (int i = 0; i < input.length() - 1; i++) {
                if ((input.charAt(i) == '(' && input.charAt(i + 1) == ')') ||
                        (input.charAt(i) == '{' && input.charAt(i + 1) == '}') ||
                        (input.charAt(i) == '[' && input.charAt(i + 1) == ']')) {
                    input = input.substring(0, i) + input.substring(i + 2);
                    System.out.println("Input is " + input);
                    validParen(input);
                }
            }
            return false;
        }
    }

    public static void main(String[] args) {
        Solution sol = new Solution();
        //System.out.println(sol.validParen("")); 
        //System.out.println(sol.validParen("()")); // returns false for some reason 
        //System.out.println(sol.validParen("()[]{}")); // returns false for some reason
        //System.out.println(sol.validParen("(]"));
        //System.out.println(sol.validParen("([)]"));
        //System.out.println(sol.validParen("{[]}")); // returns false for some reason
    }
}

类解决方案{
公共布尔值validParen（字符串输入）{
if（input.isEmpty（））{
返回true；
}
否则{
对于（int i=0；i

您是否尝试过更换

validParen(input);

与

?？ 否则，这一行实际上没什么用处；）

从调用顺序的角度来看，无论您是从

a（）

调用方法

a（）

，还是从其他任何地方调用方法

a（）

，都无关紧要。 让我们看一个简单的例子

public int getOne() {
   return 1;
}

public int getA(int a) {
   /*
   what you do here is call getOne(). The method will be called,
   and it will produce some result, but this result will not be persisted
   in any way, you will just go to the next line where the original a's
   value will be returned
    */
   getOne(); 
   return a;


}

---

这个案子更清楚一点吗？显然，如果您调用<代码> GETA（2），<代码> 2 < /C>将返回，而不是<代码> 1 >代码>，即使内部调用“代码> GETONE（））/代码>它的结果被忽略。当当前字符为

（

或

{

或

[

）时，将它们放入堆栈中。当当前字符为

）

或

}

或

]

时，检查堆栈中是否存在对应项（对于有效输入，它必须存在）并将其弹出

import java.util.Stack;

class Solution {

    public boolean validParen(String input) {

        if (input.isEmpty()) {
            return true;
        } else {
            Stack<Character> stack = new Stack<>();
            for (int i = 0; i < input.length(); i++) {
                char current = input.charAt(i);
                if (current == '(' || current == '[' || current == '{') {
                    stack.push(current);
                } else {
                    if(stack.isEmpty()) {
                          return false;
                    }
                    char peekChar = stack.peek();
                    if ((current == ')' && peekChar != '(')
                            || (current == '}' && peekChar != '{')
                            || (current == ']' && peekChar != '[')) {
                        return false;  // for a valid input, a close brackets must have an open brackets
                    } else {
                        stack.pop();
                    }
                }
            }
            return true; 
        }
    }


    public static void main(String[] args) {
        Solution sol = new Solution();
        System.out.println(sol.validParen(""));
        System.out.println(sol.validParen("()"));
        System.out.println(sol.validParen("()[]{}"));
        System.out.println(sol.validParen("(]"));
        System.out.println(sol.validParen("([)]"));
        System.out.println(sol.validParen("{[]}"));
    }

}

import java.util.Stack；
类解决方案{
公共布尔值validParen（字符串输入）{
if（input.isEmpty（））{
返回true；
}否则{
堆栈=新堆栈（）；
对于（int i=0；i

导入java.util.Stack

公共级有效赛车手{

public static void main(String[] args) {

    System.out.println(isValid("( [ { } ] )".toCharArray())); // valid
    System.out.println(isValid("([{}])".toCharArray())); // valid
    System.out.println(isValid("([)]".toCharArray())); // invalid
    System.out.println(isValid("(}".toCharArray())); // invalid

}

public static boolean isValid(char[] charArray) {
    Stack<Character> container = new Stack<Character>();

    for (char c : charArray) {

        if (c == ' ') {
            continue;
        }

        if (c == '(' || c == '{' || c == '[') {
            container.push(c);
        } else if (c == ')' && container.peek() == '(' 
                || (c == '}' && container.peek() == '{')
                || (c == ']' && container.peek() == '[')) {
            container.pop();
        } else {
            return false;
        }

    }

    return container.isEmpty();
}

publicstaticvoidmain（字符串[]args）{
System.out.println（isValid（（[{}]）”.toCharArray（））；//有效
System.out.println（isValid（（[{}]）”.toCharArray（））；//有效
System.out.println（isValid（“（[）]”）.toCharArray（））；//无效
System.out.println（isValid（“（}.toCharArray（））；//无效
}
公共静态布尔值isValid（char[]charArray）{
堆栈容器=新堆栈（）；
用于（字符c:charArray）{
如果（c=''）{
继续；
}
如果（c=='（'| | c=='{'| | c=='['）{
容器。推（c）；
}如果（c=='）和&container.peek（）=='（'
||（c=='}'&&container.peek（）=='{'）
||（c==']'&&container.peek（）=='['））{
container.pop（）；
}否则{
返回false；
}
}
返回容器.isEmpty（）；
}

}

公共布尔值有效（字符串s）{
堆栈=新堆栈（）；
对于（int i=0；i

这应该是一个优雅的版本，在这个版本中，您可以按下括号的反面，检查完整性

公共布尔值有效（字符串s）{
堆栈=新堆栈（）；
for（char c:s.toCharArray（））{
如果（c=='（'）
堆栈推送（'）；
else如果（c=='{'）
public static void main(String[] args) {

    System.out.println(isValid("( [ { } ] )".toCharArray())); // valid
    System.out.println(isValid("([{}])".toCharArray())); // valid
    System.out.println(isValid("([)]".toCharArray())); // invalid
    System.out.println(isValid("(}".toCharArray())); // invalid

}

public static boolean isValid(char[] charArray) {
    Stack<Character> container = new Stack<Character>();

    for (char c : charArray) {

        if (c == ' ') {
            continue;
        }

        if (c == '(' || c == '{' || c == '[') {
            container.push(c);
        } else if (c == ')' && container.peek() == '(' 
                || (c == '}' && container.peek() == '{')
                || (c == ']' && container.peek() == '[')) {
            container.pop();
        } else {
            return false;
        }

    }

    return container.isEmpty();
}

public boolean isValid(String s) {
    Stack<Character> stack = new Stack<>();
    for(int i =0; i < s.length(); i++){
       Character currentChar = s.charAt(i);
       if (currentChar == '(' || currentChar == '{' || currentChar == '[') {
            stack.push(currentChar);
       } else if(!stack.isEmpty()){
           if (currentChar == ')' && stack.peek() == '(' 
            || (currentChar == '}' && stack.peek() == '{')
            || (currentChar == ']' && stack.peek() == '[')) {
                stack.pop();
            } else {
                return false;
            }
       } else {
            return false;
        }
    }

    return stack.isEmpty();
}