檢查 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));
    }
}