检查 java 中的有效括号

Question

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

1.开括号必须用相同类型的括号闭合。
2.开括号必须以正确的顺序闭合。 3.空字符串有效

但是，我下面使用递归的代码不适用于有效案例。 假设 go 为基本情况（当输入为“”时），而是在 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
    }
}

Answer 1

正如评论中所说，您可以考虑使用堆栈。 当前字符为(或{或[时，将它们放入堆栈。当前字符为)或}或]时，检查堆栈中是否存在对应项（对于有效输入，它必须存在）并弹出它。

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("{[]}"));
    }

}

Answer 2

你试过更换

validParen(input);

和

return validParen(input);

? 否则这条线并没有真正做太多;）

从调用顺序的角度来看，您是从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而不是1 ，即使在内部调用getOne() - 它的结果也会被忽略。

Answer 3

导入 java.util.Stack；

公共 class ValidBracesTest {

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();
}

}

Answer 4

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();
}

Answer 5

这应该是一个优雅的版本，您可以在其中推动括号的反面并检查完整性。

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

Answer 6

class Solution {
    public static boolean isValid(String s) {
        HashMap<Character, Character> map = new HashMap<Character, Character>();
        map.put('(', ')');
        map.put('[', ']');
        map.put('{', '}');

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

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

            if (map.keySet().contains(curr)) {
                stack.push(curr);
            } else if (map.values().contains(curr)) {
                if (!stack.empty() && map.get(stack.peek()) == curr) {
                    stack.pop();
                } else {
                    return false;
                }
            }
        }

        return stack.empty();
    }
}

Answer 7

除了堆栈，我们也可以使用列表。下面是一个可行的解决方案：

import java.util.ArrayList;
import java.util.List;

public class ValidParenthesis {

    public static boolean checkParenthesis(String str) {
        char[] arr=str.toCharArray();
        List<String> list=new ArrayList<>();
        
        for(int i=0;i<arr.length;i++) {
            if(arr[i]=='{'||arr[i]=='('||arr[i]=='[') {
                list.add(Character.toString(arr[i]));
                continue;
            }else {
                if(arr[i]=='}') {
                    if(list.get(list.size()-1).equals("(")|| list.get(list.size()-1).equals("[")) {
                        return false;
                    }else {
                        list.remove(list.size()-1);
                    }
                }else if(arr[i]==']') {
                    if(list.get(list.size()-1).equals("(")|| list.get(list.size()-1).equals("{")) {
                        return false;
                    }else {
                        list.remove(list.size()-1);
                    }
                }else if(arr[i]==')') {
                    if(list.get(list.size()-1).equals("[")|| list.get(list.size()-1).equals("{")) {
                        return false;
                    }else {
                        list.remove(list.size()-1);
                    }
                }
            }
            
        }
        return true;
    }
    public static void main(String[] args) {
        
        String str="[()]{}{[()()]()}";
        System.out.println(checkParenthesis(str));
        str="[(])";
        System.out.println(checkParenthesis(str));
    }
}