Java中平衡括号程序中的错误 我正在使用Java程序为括号表达式寻找平衡括号的条件 括号表达式被称为是平衡的，如果 它没有不匹配的括号。 在一对匹配括号的范围内封闭的括号子集也是一对匹配括号 例如，如果输入为{[（）]}，则平衡括号的条件为是，如果不满足条件，则条件为否 当尝试使用测试用例{（（[]）[]]]}时，平衡括号的状态显示为YES，而不是预期的输出NO 我研究并调试了代码，并将错误显示为堆栈元素中缺少未完成的括号 你们能提供你们的建议来帮助解决这个问题吗 提供以下完整代码： import java.io.*； 导入java.math.*； 导入java.security.*； 导入java.text.*； 导入java.util.*； 导入java.util.concurrent.*； 导入java.util.regex.*； 公共类解决方案{ //完成下面的isBalanced功能。 静态字符串已平衡（字符串s）{ 堆栈括号=新堆栈（）； 字符串判定；字符元素； //char[]s_new=s.toCharArray（）； 对于（inti=0；i

我认为，它对你有用

   public class Solution {   
        public static boolean validBraces(String input){
            String previous = "";
            while (input.length() != previous.length())
            {
                previous = input;
                System.out.println("input"+input+"              previous"+previous);
                input = input
                    .replace("()", "")
                    .replace("[]", "")
                    .replace("{}", "");            

             }
            return (input.length() == 0);
          }

        public static void main(String[] args) {
        System.out.println(validBraces("(}[]" ));
        }
    }

---

实际上，您缺少一个条件……如果当前元素=s.charAt（i）与stack.peep（）不匹配该怎么办？您需要中断for循环。 在for循环中添加else条件

'''
  for(int i=0; i<s.length(); i++){
            element = s.charAt(i);
            if(element == '{' || element == '[' || element == '(')
                bracket.push(element);
                //System.out.println(element);
            if((!bracket.empty()) && (element == '}') && (bracket.peek()=='{'))
                bracket.pop();
            else if((!bracket.empty()) && (element == ']') && (bracket.peek()=='['))
                bracket.pop();
            else if((!bracket.empty()) && (element == ')') && (bracket.peek()=='('))
                bracket.pop();
            else
                break;
            System.out.println(bracket);
        }

“”
对于（int i=0；i您错过了一个条件。如果当前元素是一个结束括号，但堆栈顶部没有打开同一个括号中的一个？只需考虑以下输入：“}”。由于没有开始括号，堆栈没有被推入任何括号。由于堆栈为空，因此也没有弹出（）

所以在循环结束后，括号是空的，决策被初始化为“是”。所以您得到的是“是”
我建议您首先绘制一个算法来解决这类问题，不管怎样，正如上面的答案所指出的，您缺少break语句，并且您可以使用更有效的调试技术，例如将问题分解为更简单的问题。在这种情况下，是的，您有调试打印，但您还需要通过您为其绘制的算法来验证程序的正确性

因此，作为调试这个问题的示例，我将编写一个较小的程序，它可以更好地帮助我理解问题的本质

import java.io.*;
import java.math.*;
import java.security.*;
import java.text.*;
import java.util.*;
import java.util.concurrent.*;
import java.util.regex.*;

public class Main {

  // Complete the isBalanced function below.
  static String isBalanced(String s) {
    Stack<Character> bracket = new Stack<Character>();
    String decision;
    char element;
    // char[] s_new = s.toCharArray();
    for (int i = 0; i < s.length(); i++) {
      element = s.charAt(i);
      if (element == '{' || element == '[' || element == '(')
        bracket.push(element);
      // System.out.println(element);
      if ((!bracket.empty()) && (element == '}') && (bracket.peek() == '{'))
        bracket.pop();
      else if (element == '}' && (bracket.peek() != '{'))
        break;
      if ((!bracket.empty()) && (element == ']') && (bracket.peek() == '['))
        bracket.pop();
      else if (element == ']' && (bracket.peek() != '['))
        break;
      if ((!bracket.empty()) && (element == ')') && (bracket.peek() == '('))
        bracket.pop();
      else if (element == ')' && (bracket.peek() != '('))
        break;
      System.out.println(bracket);
    }
    if (bracket.empty())
      decision = "YES";
    else
      decision = "NO";
    System.out.println(bracket);

    return decision;
  }

  public static void main(String[] args) throws IOException {

    String s = "{(([])[])[]}";
    String result = isBalanced(s);

    System.out.println(result);

  }
} 

import java.io.*；
导入java.math.*；
导入java.security.*；
导入java.text.*；
导入java.util.*；
导入java.util.concurrent.*；
导入java.util.regex.*；
公共班机{
//完成下面的isBalanced功能。
静态字符串已平衡（字符串s）{
堆栈括号=新堆栈（）；
字符串决策；
碳元素；
//char[]s_new=s.toCharArray（）；
对于（int i=0；i
以下是平衡支架JAVA 8的完整解决方案

import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;

public class Solution {

    public static boolean isBalanced(String expression) {
        char[] braces = expression.toCharArray();
        if(braces.length%2!=0){
            return false;
        }
        Map<Character, Character> endbrackets = new HashMap<Character, Character>();
        endbrackets.put('{', '}');
        endbrackets.put('[', ']');
        endbrackets.put('(', ')');
        if(endbrackets.get(braces[0]) == null){
            return false;
        }
        Stack<Character> stack= new Stack<Character>(); 
        for(int i=0; i < braces.length; i++){
            Character c = braces[i];  
            if(stack.isEmpty() && endbrackets.get(c) == null){
                 return false;
            }               
            else if(stack.isEmpty() || endbrackets.get(c) != null){
               stack.push(c); 
            }
            else if(!stack.isEmpty() && endbrackets.get(stack.peek()).equals(c)){
                stack.pop();
            } else {
                return false;
            }
        }
        if(stack.size() == 0){
            return true;
        }
        return false;
    }

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int t = in.nextInt();
        for (int a0 = 0; a0 < t; a0++) {
            String expression = in.next();
            System.out.println( (isBalanced(expression)) ? "YES" : "NO" );
        }
    }
}

import java.io.*；
导入java.util.*；
导入java.text.*；
导入java.math.*；
导入java.util.regex.*；
公共类解决方案{
公共静态布尔值isBalanced（字符串表达式）{
char[]大括号=expression.toCharArray（）；
if（大括号。长度%2！=0）{
返回false；
}
Map end括号=新的HashMap（）；
放（'{'，'}'）；
放（'['，']'）；
结束括号。放（“（”，“）”）；
if（end括号.get（括号[0]）==null）{
返回false；
}
堆栈=新堆栈（）；
for（int i=0；i
简单一点

public static boolean isBalanced(String str) {
    Deque<Character> stack = new LinkedList<>();

    for (int i = 0; i < str.length(); i++) {
        char ch = str.charAt(i);

        if (ch == '{' || ch == '(' || ch == '[')
            stack.push(ch);
        else if (ch == '}' || ch == ')' || ch == ']') {
            if (stack.isEmpty())
                return false;

            char prv = stack.pop();

            if (prv == '{' && ch != '}')
                return false;
            if (prv == '(' && ch != ')')
                return false;
            if (prv == '[' && ch != ']')
                return false;
        }
    }

    return stack.isEmpty();
}

公共静态布尔值isBalanced（字符串str）{
Deque stack=newlinkedlist（）；
对于（int i=0；ipublic static boolean isBalanced(String str) {
    Deque<Character> stack = new LinkedList<>();

    for (int i = 0; i < str.length(); i++) {
        char ch = str.charAt(i);

        if (ch == '{' || ch == '(' || ch == '[')
            stack.push(ch);
        else if (ch == '}' || ch == ')' || ch == ']') {
            if (stack.isEmpty())
                return false;

            char prv = stack.pop();

            if (prv == '{' && ch != '}')
                return false;
            if (prv == '(' && ch != ')')
                return false;
            if (prv == '[' && ch != ']')
                return false;
        }
    }

    return stack.isEmpty();
}

package com.coursera.course2.week1;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
import java.util.Stack;

class Bracket {

    char type;
    int position;

    Bracket(char type, int position) {
        this.type = type;
        this.position = position;
    }

    boolean Match(char c) {
        if (this.type == '[' && c == ']')
            return true;
        if (this.type == '{' && c == '}')
            return true;
        if (this.type == '(' && c == ')')
            return true;
        return false;
    }

}

class check_brackets {
    public static void main(String[] args) throws IOException {
        InputStreamReader input_stream = new InputStreamReader(System.in);
        BufferedReader reader = new BufferedReader(input_stream);
        String text = reader.readLine();
        Stack<Bracket> opening_brackets_stack = new Stack<Bracket>();
        for (int position = 0; position < text.length(); ++position) {
            char next = text.charAt(position);

            if (next == '(' || next == '[' || next == '{') {
                opening_brackets_stack.push(new Bracket(next,position));
            } else if (next == ')' || next == ']' || next == '}') {
                 if(!opening_brackets_stack.isEmpty() && opening_brackets_stack.peek().Match(next)) {
                     opening_brackets_stack.pop();

                 } else {
                     opening_brackets_stack.push(new Bracket(next,position));
                     break;
                 }

            }



        }
        if(opening_brackets_stack.isEmpty()) {
            System.out.println("Success");
        } else {
            System.out.println(opening_brackets_stack.pop().position+1);
        }
    }
}

static String  isBalanced(String s) {
    Stack<Character> bracket = new Stack<Character>();

    String decision;
    char element;
    //char[] s_new = s.toCharArray();

    for (int i = 0; i < s.length(); i++) {
        element = s.charAt(i);
        if (element == '{' || element == '[' || element == '(')
            bracket.push(element);
        else if(bracket.empty() && (element =='}' || element ==']' || element ==')'))
        {
            bracket.push(element);
            break;
        } // *******Added this 'else if' block  to support point no 2*******


        if ((!bracket.empty()) && (element == '}') && (bracket.peek() == '{'))
            bracket.pop();
        else if ((!bracket.empty()) && (element == '}') && (bracket.peek() != '{'))
            break; // *******Added this 'else if' block to support point no 1

        if ((!bracket.empty()) && (element == ']') && (bracket.peek() == '['))
            bracket.pop();
        else if ((!bracket.empty()) && (element == ']') && (bracket.peek() != '['))
            break; // *******Added this 'else if' block to support point no 1

        if ((!bracket.empty()) && (element == ')') && (bracket.peek() == '('))
            bracket.pop();
        else if ((!bracket.empty()) && (element == ')') && (bracket.peek() != '('))
            break; // *******Added this 'else if' block to support point no 1

        System.out.println(bracket);
    }
    if (bracket.empty())
        decision = "YES";
    else
        decision = "NO";
    System.out.println(bracket);

    return decision;
}