Question

我需要编写一个java程序来告诉你括号是否在字符串中是平衡的，但我找不到正确的方法。我已经知道我将使用循环来计算存储在整数中的开括号和闭括号"(" = 1 and ")" = -1，该整数将以0或其他任何内容返回。

我只是不知道如何以这种方式计算括号。

编辑：为了更清楚，我真正需要的是一种计算括号的方法，我被阻止了，因为我无法使用类似的东西：

if（args [i] =='（'）//解释器不允许我将字符串与字符进行比较计数++;

编辑2：

public class Testing_grounds {
    public static void main(String[] args) {
        String str = args[];
        char RetV[] = str.toCharArray();
        int counter = 0;
        for (int n = 0; n <= RetV.length; n++) {
            if (RetV[n] == '(')
                counter++;
            else if (RetV[n] == ')')
                counter--;
        }
        if (counter == 0)
            System.out.println("The parentheses are balenced!");
        else if(counter < 0)
            System.out.println("There are to many closed parenthesis!");
        else if(counter > 0)
            System.out.println("There are to many opened parenthesis!");
    }
}

这几乎是我想要的代码（我正在尝试使用toCharArray（）方法，但是我继续在第3行获得类预期错误。那条线是因为它不会让我这样做：args.toCharArray）

请记住，我需要使用输入而不是代码中已存在的字符串来执行此操作。

Answer 1

如果逐个字符地扫描字符串，那么你可以这样做：

int counter = 0;
for (int i=0; i<text_length; i++) {
    if (text[i] == '(') counter++;
    else if (text[i] == ')') counter--;

    if (counter < 0) break;
}

if (counter != 0) error();

此代码考虑了括号的顺序，因此＆＃34;）（＆＃34;将被检测为错误。

修改：

要在Java中执行相同的操作，您可以这样做：

int counter = 0; for (char ch : text.toCharArray()) if (ch == '(') counter++; else if (ch == ')') counter--; if (counter < 0) break; } if (counter != 0) error();

希望它有所帮助。

Answer 2

实际上你可以通过以下几种方式实现：

1）使用堆栈。每次看到(时都会推送一个值，并在每次看到)时弹出一个值。如果没有什么可以弹出（堆栈异常）那么它就不平衡了。这种方法很好，因为如果你使用char的堆栈，你可以通过简单地将右括号映射到左括号（即] -> [, ) -> (, } -> {）并检查是什么来扩展它以处理其他类型的括号你弹出的对于你在字符串中遇到的东西是好的。

这样的事情：

Stack<Character> openParens = new Stack<>();
for(Character ch: text.toCharArray()) {
    if(ch == '(') {
        openParens.push(ch);
    } else if(ch == ')') {
        if(openParens.empty()) {
            return false; //unbalanced
        } else {
            openParens.pop();
        }
    }
}
return true;

如果括号顺序不重要，这将不起作用。

2）使用计数器，当您看到1时添加(，并在看到1时删除)。如果你低于0则返回false（不平衡）。或者直到字符串结尾，然后检查计数是否为0，这将处理您不需要排序的情况（仅当( = )的计数时）

@EDIT：

好的，如果你不提供索引（即String str = args[];），问题是String str = args[0];将无法编译。另外，您无法在toCharArray()上致电args，因为这是String类定义的方法，而args是String的数组第

我不建议传递你想要计算的文本，之后使用起来并不容易。相反，如果您确定包含您的文本的测试文件名并改为读取它？

Answer 3

从头到尾读取字符串，使用堆栈计算括号。只将左括号推入堆栈，如果遇到右括号则弹出一个。

所以像（（a + x）*（b + y））会在末尾留下一个空堆栈，告诉你括号是平衡的。

您是否还需要考虑订单，例如：（a + b）））（（？

Answer 4

好吧，如果您想计算字符串中平衡括号的数量，那么遵循以下Java代码可能会有所帮助

 int open=0,close=0;
    Stack<Character> openbrace = new Stack<Character>();

    for( char c : sample.toCharArray())
    {
        if(c=='(') {
            openbrace.push(c);
            open++;
            }
        else if(c==')') {
            if(openbrace.isEmpty()==false) {    openbrace.pop();}
            close++;
            }
    }

    if(open-close!=0)
        System.out.println("unbalanced ");
    else
        System.out.println("balanced");
    System.out.println(" count of balanced brace="+Math.min(open, close));

Answer 5

函数计算不平衡的括号。

public static int bracketMatch(String bracketString) {   

    Stack<Character>opening = new Stack<Character>();
    Stack<Character>closing = new Stack<Character>();
    char [] brackets = bracketString.toCharArray();
    for (char bracket: brackets) {

        if (bracket == '(') {
            opening.push(bracket);
        } else if (bracket == ')') {
            if (opening.size() > 0) {
                opening.pop();
            }
            else {
                closing.push(bracket);
            }
        }
    }

    return  opening.size()+closing.size();
}

Answer 6

这是工作代码，当不匹配时返回匹配计数和-1。

public int matchedCount(){
        Scanner scan = new Scanner(System.in);
        Stack<Integer> stk = new Stack<Integer>();
        System.out.println("Enter expression");
        String exp = scan.next();        
        int len = exp.length();
        System.out.println("\nMatches and Mismatches:\n");
        int counter = 0;
        for (int i = 0; i < len; i++)
        {    
            char ch = exp.charAt(i);
            if (ch == '(')
                stk.push(i);
            else if (ch == ')')
            {
                try
                {
                    int p = stk.pop() + 1;
                    counter++;
                }
                catch(Exception e)
                {
                    return -1;
                }
            }            
        }

        while (!stk.isEmpty() )
            return -1; 
        return counter;
    }

Answer 7

public class Practice {

    public static void main(String[] args) {

        String str = "([{{[(())]}}";

        int OpenCurlyBracket = 0;
        int ClosedCurlyBracket = 0;
        int OpenSquareBracket = 0;
        int ClosedSquareBracket = 0;
        int OpenRoundBracket = 0;
        int ClosedRoundBracket = 0;
        int curlyBracketCount = 0;
        int roundBracketCount = 0;
        int squareBracketCount = 0;

        for (char ch: str.toCharArray()) {

            switch (ch) {
            case '{': OpenCurlyBracket ++;

            break;
            case '[': OpenSquareBracket++;

            break;
            case '(': OpenRoundBracket ++;

            break;
            case '}': ClosedCurlyBracket ++;

            break;
            case ']': ClosedSquareBracket ++;

            break;
            case ')': ClosedRoundBracket ++;

            default:
                break;
            }

        }
        if (OpenCurlyBracket == ClosedCurlyBracket) {
            int counta = (OpenCurlyBracket+ClosedCurlyBracket);
            System.out.println("Total Curly Bracket:"+counta);
            curlyBracketCount = counta/2;
        }else{
            int counta = (OpenCurlyBracket+ClosedCurlyBracket);
            System.out.println("Total Curly Bracket:"+counta);
            curlyBracketCount = counta/2;
        }
        if (OpenRoundBracket == ClosedRoundBracket) {
            int countb = (OpenRoundBracket+ClosedRoundBracket);
            System.out.println("Total Round Bracket:"+countb);
            roundBracketCount = countb/2;
        }else {

            int countb = (OpenRoundBracket+ClosedRoundBracket);
            System.out.println("Total Round Bracket:"+countb);
            roundBracketCount = countb/2;
        
        }
        
        if (OpenSquareBracket == ClosedSquareBracket) {
            int countc = (OpenSquareBracket+ClosedSquareBracket);
            System.out.println("Total Square Bracket:"+countc);
            squareBracketCount = countc/2;
        }else {

            int countc = (OpenSquareBracket+ClosedSquareBracket);
            System.out.println("Total Square Bracket:"+countc);
            squareBracketCount = countc/2;
        
        }

        System.out.println("");
        System.out.println("Valid Curly Bracket:"+curlyBracketCount+"\nValid Round Bracket:" +roundBracketCount+"\nValid Square Bracket:"+squareBracketCount);      

    }
}

OUTPUT:

Total Curly Bracket:4
Total Round Bracket:5
Total Square Bracket:3

Valid Curly Bracket:2
Valid Round Bracket:2
Valid Square Bracket:1

Answer 8

您可以使用以下代码获取差异：

int diff = str.replaceAll("\\(", "").length() - str.replaceAll("\\)","").length();

如果是0则括号是平衡的。

平衡括号，如何计算它们？

8 个答案: