写一份用java判断括号合法性的代码

### 回答1：

public static boolean isValidBrackets(String str) {
Stack<Character> stack = new Stack<Character>();
char c;
for(int i=0; i<str.length(); i++) {
c = str.charAt(i);
if(c=='(' || c=='[' || c=='{') {
stack.push(c);
} else if(c==')' || c==']' || c=='}') {
if(stack.isEmpty()) {
return false;
}
char topChar = stack.pop();
if(c==')' && topChar!='(') {
return false;
}
if(c==']' && topChar!='[') {
return false;
}
if(c=='}' && topChar!='{') {
return false;
}
}
}
return stack.isEmpty();
}

### 回答2：
以下是一个用Java编写的判断括号合法性的代码：

import java.util.Stack;

public class BracketValidator {
    public static boolean validate(String input) {
        Stack<Character> stack = new Stack<>();

        for (char c : input.toCharArray()) {
            if (c == '(' || c == '[' || c == '{') {
                stack.push(c);
            } else if (c == ')' || c == ']' || c == '}') {
                if (stack.isEmpty()) {
                    return false;
                }

                char top = stack.pop();

                if (c == ')' && top != '(') {
                    return false;
                } else if (c == ']' && top != '[') {
                    return false;
                } else if (c == '}' && top != '{') {
                    return false;
                }
            }
        }

        return stack.isEmpty();
    }

    public static void main(String[] args) {
        String input = "[{()}]"; // 括号序列
        boolean isValid = validate(input);

        if (isValid) {
            System.out.println("括号序列是合法的");
        } else {
            System.out.println("括号序列是非法的");
        }
    }
}

以上代码使用了一个栈数据结构，并遍历输入的括号序列。对于每个字符，如果是左括号，则入栈；如果是右括号，则与栈顶元素比较，如果匹配，则将栈顶元素出栈，否则返回false。最后，如果栈为空，则括号序列是合法的，否则是非法的。

以上代码的时间复杂度为O(n)，其中n是括号序列的长度。

### 回答3：
以下是用Java编写的代码来判断括号的合法性：

import java.util.Stack;

public class ParenthesesValidator {
    public static boolean validateParentheses(String str) {
        Stack<Character> stack = new Stack<>();

        for (char ch : str.toCharArray()) {
            if (ch == '(' || ch == '{' || ch == '[') {
                stack.push(ch);
            } else if (ch == ')' || ch == '}' || ch == ']') {
                if (stack.isEmpty()) {
                    return false;
                }

                char top = stack.pop();
                if ((ch == ')' && top != '(') || (ch == '}' && top != '{') || (ch == ']' && top != '[')) {
                    return false;
                }
            }
        }

        return stack.isEmpty();
    }

    public static void main(String[] args) {
        String str1 = "{[()]}";
        String str2 = "{[()]}(())";
        String str3 = "{[()]}{]}";
        String str4 = "{[()]}(";

        System.out.println(str1 + " 括号合法性：" + validateParentheses(str1));
        System.out.println(str2 + " 括号合法性：" + validateParentheses(str2));
        System.out.println(str3 + " 括号合法性：" + validateParentheses(str3));
        System.out.println(str4 + " 括号合法性：" + validateParentheses(str4));
    }
}

该代码使用了一个栈来存储左括号，在遍历字符串中的每个字符时，当遇到左括号时，将其压入栈中；当遇到右括号时，将栈顶的字符弹出，并判断弹出的字符与右括号是否匹配。如果栈为空或栈顶字符与右括号不匹配，则说明括号不合法。最后，如果栈为空，则说明括号是合法的。

使用给定的示例字符串进行测试，输出结果如下：

{[()]} 括号合法性：true
{[()]}(()) 括号合法性：true
{[()]}{]} 括号合法性：false
{[()]}( 括号合法性：false

以上代码可以判断给定字符串中的括号是否合法。