java中使用单堆栈和开关参数进行排序

Question

我试图编写两个方法，只使用一个堆栈和一个switch语句就可以对一串方括号进行排序。我无法让它工作，我想知道是否是因为字符串中的“”的情况？默认情况下不应该选择这些，或者我是否理解了错误的switch语句？这就是我现在的位置

out.println(checkParentheses("({} [()] ({}))"));  // should print true 
                                                                
out.println(!checkParentheses("({} [() ({)})"));  // should print false 


Boolean checkParentheses(String brackets) {

    Deque<Character> stack = new ArrayDeque<>();


    for( char ch : brackets.toCharArray()) {
        if (stack.peek() == matching(ch)) {
            stack.pop();
        } else {
           stack.add(ch);
        }
    }
    return stack.isEmpty();
}


char matching(char ch) {
    // char c = (' ');
    switch (ch) {
        case ')':
            return '(';  // c = '('
        case ']':
            return '[';
        case '}':
            return '{';
        default:
          // return c;
          throw new IllegalArgumentException("No match found");
    }
}

Answer 1

1. 在输入中应忽略非括号字符，也可以选择将输入从中清除或只是悄悄跳过
2. 需要对开启/关闭支架进行特殊检查

基本上，checkParentheses应该简单如下：

public static boolean checkParentheses(String str) {
    if (null == str || str.isEmpty()) {
        return true;
    }
    Deque<Character> stack = new ArrayDeque<>();
    
    for (char c : str.toCharArray()) {
        if (openingBracket(c)) {
            stack.push(c);
        } else if (closingBracket(c)) {
            if (stack.isEmpty() || matchingBracket(c) != stack.pop()) {
                return false;
            }
        } // else ignore non-bracket char quietly
    }
    return stack.isEmpty();
}

然后，使用switch语句，其他方法可能如下所示：

static boolean openingBracket(char c) {
    switch (c) {
        case '(': case '[': case '{': case '<':
            return true;
        default:
            return false;
    }
}

static boolean closingBracket(char c) {
    switch (c) {
        case ')': case ']': case '}': case '>':
            return true;
        default:
            return false;
    }
}

static char matchingBracket(char c) {
    switch (c) {
        case ')': return '(';
        case ']': return '[';
        case '}': return '{';
        case '>': return '<';
        default:
            throw new IllegalArgumentException("Bad character found instead of closing bracket: " + c);
    }
}

然后，测试的输出如下所示：

System.out.println(checkParentheses("({} [()] ({}))"));  // true, balance ok
                                                                
System.out.println(!checkParentheses("({} [() ({)})"));  // true, NOT balanced