平衡括号，如何计数？

Question

平衡括号，如何计数？

4

我需要编写一款Java程序，可以告诉您字符串中的括号是否平衡。虽然我已经知道要使用循环来计算开放和关闭的括号 "(" = 1 and ")" = -1，并将其存储在一个整数中，该整数将返回为0或其他值，但是我无法找到正确的方法来做到这一点。

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

编辑：为了更清晰，我真正需要的只是一种计算括号的方法，而我被阻塞了，因为我无法使用类似于以下代码的内容：

if (args[i] == '(') //解释器不允许我将字符串与字符进行比较 count++;

编辑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()方法工作，但是我一直在第三行得到“class expected”错误。那行代码存在的原因是它不允许我这样做：args.toCharArray）

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

- Thierry L

1

你可以把程序粘贴过来吗？ - Ankush soni

我认为，除此之外您还需要考虑它们的出现顺序；))((是错误的，而()()则是正确的，在这两种情况下，都将返回0。 - Fran Montero

不要忘记在引号字符串中跳过括号。这使得这个问题变得困难。 - Bathsheba

10个回答

1

从头到尾读取字符串，使用堆栈计算括号。仅将开放括号推入堆栈，如果遇到闭合括号则弹出一个。

所以像((a+x)*(b+y))这样的内容最终会在堆栈中留下空白，这告诉你括号是平衡的。

您是否还需要考虑顺序，例如：(a+b)))((？

- ThreeSidedCoin

这似乎是个好主意，但我还没有学会如何使用堆栈。而且，我只需要计数，所以像()（这样的东西）将简单地输出一个预定义的消息，说明有太多的开放括号。 - Thierry L

1

实际上你可以用几种方法来实现：

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];），它就无法编译。此外，你不能在 args 上调用 toCharArray()，因为那是 String 类上定义的一个方法，而 args 是 String 数组。

我不建议以这种方式传递要计数的文本，因为之后使用起来并不方便。你可以考虑传递包含文本的测试文件名，然后读取该文件。

- Mateusz Dymczyk

第二种方法是我尝试过的，但我一直遇到同样的问题：错误：（11,24）java：不可比较类型：java.lang.String和char。 - Thierry L

@ThierryL，您能否将您的代码添加到问题中？您是想这样比较吗 ch == ")"，其中 ch 是一个 char 吗？这不会起作用 -> 您需要使用 '。 - Mateusz Dymczyk

我放入了目前的代码，尝试使用char== '('，但问题是我会得到“无法比较char和字符串”的错误，所以现在我正在尝试使用toCharArray()方法，但仍然遇到问题。 - Thierry L

0

嗯，如果你想在一个字符串中计算平衡括号的数量，下面的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));

- Conner

0

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

- Austin

你应该为那段代码提供解释，仅有代码的答案通常不被推荐（除非代码非常易于理解和清晰明了）。 - astroide

0

    package com.company;

import java.util.Scanner;

public class Main {


    public static void main(String args[])
    {
        Scanner sc = new Scanner(System.in);
        System.out.println("Enter string full of parenthesis : ");
        String input = sc.next();
        char s1 = '{';
        char s2 = '}';
        char s3 = '(';
        char s4 = ')';
        char s5 = '[';
        char s6 = ']';


        int c1=0;
        int c2=0;
        int c3 =0;
        int c4 = 0;
        int c5 =0;
        int c6= 0;
        for(int i=0; i<input.length(); i++)
        {
            if(input.charAt(i) == s1) {
                c1++;
            }

            if(input.charAt(i) == s2) {
                c2++;
            }
            if(input.charAt(i) == s3) {
                c3++;
            }

            if(input.charAt(i) == s4) {
                c4++;
            }

            if(input.charAt(i) == s5) {
                c5++;
            }

            if(input.charAt(i) == s6) {
                c6++;
            }
        }
        if( c1-c2 >= 0){
            System.out.println( s1 + " is unbalanced by :" + ( c1 - c2));
        }
        if( c2-c1 >= 0){
            System.out.println( s2 + " is unbalanced by :" + ( c2 - c1));
        }
        if( c3-c4 >= 0){
            System.out.println( s3 + " is unbalanced by :" + ( c3 - c4));
        }
        if( c4-c3 >= 0){
            System.out.println( s4 + " is unbalanced by :" + ( c4 - c3));
        }
        if( c5-c6 >= 0){
            System.out.println( s5 + " is unbalanced by :" + ( c5 - c6));
        }
        if( c6-c5 >= 0){
            System.out.println( s6 + " is unbalanced by :" + ( c6 - c5));
        }

//        System.out.println("The Character '"+search+"' appears "+count+" times.");
    }
    }

- Saurav Gaur

1

请添加更多细节以扩展您的答案，例如工作代码或文档引用。 - Community

0

这个函数用于计算不平衡的括号。

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();
}

- Naeem

0

这里是可工作的代码，它会返回匹配计数和未匹配时的-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;
    }

- Jaydeep Shil

0

这些都是很好的答案，但我真的想要一种计数方法，可以考虑单引号和双引号。因为有时候我会在它们里面藏着括号或大括号，这会影响计数。

- Jim

-2

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

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

如果是0，那么括号是平衡的。

- Nitesh Virani

为什么是-1？有什么原因吗？ - Nitesh Virani

@MateuszDymczyk 您是正确的，a)(a 不是有效的文本，但他想检查文本中 ( 和 ) 是否相等。 - Nitesh Virani

好的，我没有给你投反对票，但通常平衡的括号也意味着顺序很重要。 - Mateusz Dymczyk

网页内容由stack overflow 提供, 点击上面的

可以查看英文原文，
原文链接

- castarco · Accepted Answer

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

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();

这段代码考虑了括号的顺序，因此 ")(" 将被识别为错误。

编辑：

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

int counter = 0;
for (char ch : text.toCharArray())
    if (ch == '(') counter++;
    else if (ch == ')') counter--;

    if (counter < 0) break;
}
if (counter != 0) error();

希望能对您有所帮助。