Java 无法检查字符串是否平衡

作为一种查看堆栈中是否还有任何内容的方法，但它仍然不适合我。有什么建议吗

例如，如果字符串输入是

（）{（）

，那么程序应该像正常一样运行，直到到达单个

{

，然后代码应该意识到字符串是不平衡的，并且输出是不平衡的

---

无论出于何种原因，我的代码都没有这样做。

以下逻辑有缺陷（我的）：

例如，如果字符串输入是

（）{（）

，那么程序应该像正常的一样运行，直到到达单个

{

，然后代码应该意识到字符串不平衡，输出不平衡

事实上，在扫描整个字符串并确定

{

没有匹配的

}

之前，代码无法断定字符串是不平衡的。据它所知，完整的输入可以是

（）{（）}

，并且是平衡的

---

要实现这一点，您需要添加一个检查，以确保在处理完整个字符串后堆栈为空{，表示输入不平衡。

我尝试回答了这个问题。如果字符串平衡，我的解决方案将返回true，并强制执行开始/结束顺序（即

（{}

返回false）。我从您的代码开始，尝试将其精简

else if (stack.size() > 0) {
                    System.out.println("Unbalanced");
                    break;
                }

import java.util.HashMap；
导入java.util.Map；
导入java.util.Stack；
公共类乳房{
私有静态最终字符openPara='（'；
私有静态最终字符openBracket='['；
私有静态最终字符openCurly='{'；
私有静态最终字符openArrow=''；
公共静态void main（字符串…参数）{
System.out.println（checkString（“{}[]（）90”）；//true
System.out.println（checkString（（（））））；//false
System.out.println（checkString（（（））））；//false
System.out.println（checkString（“>”）；//false
System.out.println（checkString（“[”）；//false
System.out.println（checkString（“{[（）]}”）；//true
System.out.println（checkString（“{[（）}]”）；//false
System.out.println（checkString（“（a（b）（c）（d（e（f）g）h）I（jl）m）”）；//true
}
公共静态布尔检查字符串（字符串stringToCheck）{
final Map closeToOpenMap=新HashMap（）；
closeToOpenMap.put（closePara，openPara）；
closeToOpenMap.put（关闭支架，打开支架）；
closeToOpenMap.put（closeCurly，openCurly）；
closeToOpenMap.put（closeArrow，openArrow）；
堆栈=新堆栈（）；
final char[]stringAsChars=stringToCheck.tocharray（）；
对于（int i=0；i

这里有另一种方法：

import java.util.HashMap;
import java.util.Map;
import java.util.Stack;

public class mamurphy {

  private static final char openPara = '(';
  private static final char openBracket = '[';
  private static final char openCurly = '{';
  private static final char openArrow = '<';
  private static final char closePara = ')';
  private static final char closeBracket = ']';
  private static final char closeCurly = '}';
  private static final char closeArrow = '>';


  public static void main(String... args) {
    System.out.println(checkString("{}[]()90<>"));//true
    System.out.println(checkString("(((((())))"));//false
    System.out.println(checkString("((())))"));//false
    System.out.println(checkString(">"));//false
    System.out.println(checkString("["));//false
    System.out.println(checkString("{[(<>)]}"));//true
    System.out.println(checkString("{[(<>)}]"));//false
    System.out.println(checkString("( a(b) (c) (d(e(f)g)h) I (j<k>l)m)"));//true
  }

  public static boolean checkString(String stringToCheck) {
    final Map<Character, Character> closeToOpenMap = new HashMap<>();
    closeToOpenMap.put(closePara, openPara);
    closeToOpenMap.put(closeBracket, openBracket);
    closeToOpenMap.put(closeCurly, openCurly);
    closeToOpenMap.put(closeArrow, openArrow);
    Stack<Character> stack = new Stack<>();
    final char[] stringAsChars = stringToCheck.toCharArray();
    for (int i = 0; i < stringAsChars.length; i++) {
      final char current = stringAsChars[i];
      if (closeToOpenMap.values().contains(current)) {
        stack.push(current); //found an opening char, push it!
      } else if (closeToOpenMap.containsKey(current)) {
        if (stack.isEmpty() || closeToOpenMap.get(current) != stack.pop()) {
          return false;//found closing char without correct opening char on top of stack
        }
      }
    }
    if (!stack.isEmpty()) {
      return false;//still have opening chars after consuming whole string
    }
    return true;
  }
}

private static final char[]openParens=“[（{）.tocharray（）；
公共静态布尔值isBalanced（字符串表达式）{
Deque stack=new ArrayDeque（）；
for（char c:expression.toCharArray（））{
for（int i=0；i

它将逻辑简化为具有两个对应的打开和关闭符号数组。您也可以在一个数组中使用偶数和奇数位置执行此操作，例如“{}”：

    private static final char[] openParens = "[({<".toCharArray();
    private static final char[] closeParens = "])}>".toCharArray();

    public static boolean isBalanced(String expression){
        Deque<Character> stack = new ArrayDeque<>();
        for (char c : expression.toCharArray()){
            for (int i = 0; i < openParens.length; i++){
                if (openParens[i] == c){
                    // This is an open - put it in the stack
                    stack.push(c);
                    break;
                }
                if (closeParens[i] == c){
                    // This is a close - check the open is at the top of the stack
                    if (stack.poll() != openParens[i]){
                        return false;
                    }
                    break;
                }
            }
        }
        return stack.isEmpty();
    }

private static final char[]symbols=“[]（）{}”.tocharray（）；
公共静态布尔值isBalanced（字符串表达式）{
Deque stack=new ArrayDeque（）；
for（char c:expression.toCharArray（））{
对于（int i=0；i

请注意，如果堆栈为空，poll将返回null，因此，如果堆栈用完，将正确地使相等比较失败

例如，如果字符串输入是（）{（），那么程序应该像正常的一样运行，直到到达单个{，然后代码应该意识到字符串是不平衡的，输出是不平衡的

您的示例不清楚边界是否可以像

（[{}]）

那样嵌套。如果可以，则该逻辑将不起作用，因为必须使用整个字符串以确保任何缺少的结束符不在末尾，因此，无法可靠地认为字符串在您指示的点处不平衡

以下是我对你问题的看法：

余额检查器类：

    private static final char[] symbols = "[](){}<>".toCharArray();

    public static boolean isBalanced(String expression){
        Deque<Character> stack = new ArrayDeque<>();
        for (char c : expression.toCharArray()){
            for (int i = 0; i < symbols.length; i += 2){
                if (symbols[i] == c){
                    // This is an open - put it in the stack
                    stack.push(c);
                    break;
                }
                if (symbols[i + 1] == c){
                    // This is a close - check the open is at the top of the stack
                    if (stack.poll() != symbols[i]){
                        return false;
                    }
                    break;
                }
            }
        }
        return stack.isEmpty();
    }

package so_q33378870;

import java.util.Stack;

public class BalanceChecker {

    private final char[] opChars = "([{<".toCharArray();
    private final char[] edChars = ")]}>".toCharArray();

    //<editor-fold defaultstate="collapsed" desc="support functions">
    public boolean isOPChar(char c) {
        for (char checkChar : opChars) {
            if (c == checkChar) {
                return true;
            }
        }
        return false;
    }

    public boolean isEDChar(char c) {
        for (char checkChar : edChars) {
            if (c == checkChar) {
                return true;
            }
        }
        return false;
    }

    //NOTE: Unused.
//  public boolean isBoundaryChar(char c) {
//      boolean result;
//      if (result = isOPChar(c) == false) {
//          return isEDChar(c);
//      } else {
//          return result;
//      }
//  }

    public char getOpCharFor(char c) {
        for (int i = 0; i < edChars.length; i++) {
            if (c == edChars[i]) {
                return opChars[i];
            }
        }
        throw new IllegalArgumentException("The character (" + c + ") received is not recognized as a closing boundary character.");
    }
//</editor-fold>

    public boolean isBalanced(char[] charsToCheck) {
        Stack<Character> checkStack = new Stack<>();
        for (int i = 0; i < charsToCheck.length; i++) {
            if (isOPChar(charsToCheck[i])) {
                //beginning char found. Add to top of stack.
                checkStack.push(charsToCheck[i]);
            } else if (isEDChar(charsToCheck[i])) {
                if (checkStack.isEmpty()) {
                    //ending char found without beginning chars on the stack. UNBALANCED.
                    return false;
                } else if (getOpCharFor(charsToCheck[i]) == checkStack.peek()) {
                    //ending char found matches last beginning char on the stack. Pop and continue.
                    checkStack.pop();
                } else {
                    //ending char found, but doesn't match last beginning char on the stack. UNBALANCED.
                    return false;
                }
            }
        }
        //the string is balanced if and only if the stack is empty at the end.
        return checkStack.empty();
    }

    public boolean isBalanced(String stringToCheck) {
        return isBalanced(stringToCheck.toCharArray());
    }
}

软件包so_Q3378870；
导入java.util.Stack；
公共类平衡
package so_q33378870;

import java.util.Stack;

public class BalanceChecker {

    private final char[] opChars = "([{<".toCharArray();
    private final char[] edChars = ")]}>".toCharArray();

    //<editor-fold defaultstate="collapsed" desc="support functions">
    public boolean isOPChar(char c) {
        for (char checkChar : opChars) {
            if (c == checkChar) {
                return true;
            }
        }
        return false;
    }

    public boolean isEDChar(char c) {
        for (char checkChar : edChars) {
            if (c == checkChar) {
                return true;
            }
        }
        return false;
    }

    //NOTE: Unused.
//  public boolean isBoundaryChar(char c) {
//      boolean result;
//      if (result = isOPChar(c) == false) {
//          return isEDChar(c);
//      } else {
//          return result;
//      }
//  }

    public char getOpCharFor(char c) {
        for (int i = 0; i < edChars.length; i++) {
            if (c == edChars[i]) {
                return opChars[i];
            }
        }
        throw new IllegalArgumentException("The character (" + c + ") received is not recognized as a closing boundary character.");
    }
//</editor-fold>

    public boolean isBalanced(char[] charsToCheck) {
        Stack<Character> checkStack = new Stack<>();
        for (int i = 0; i < charsToCheck.length; i++) {
            if (isOPChar(charsToCheck[i])) {
                //beginning char found. Add to top of stack.
                checkStack.push(charsToCheck[i]);
            } else if (isEDChar(charsToCheck[i])) {
                if (checkStack.isEmpty()) {
                    //ending char found without beginning chars on the stack. UNBALANCED.
                    return false;
                } else if (getOpCharFor(charsToCheck[i]) == checkStack.peek()) {
                    //ending char found matches last beginning char on the stack. Pop and continue.
                    checkStack.pop();
                } else {
                    //ending char found, but doesn't match last beginning char on the stack. UNBALANCED.
                    return false;
                }
            }
        }
        //the string is balanced if and only if the stack is empty at the end.
        return checkStack.empty();
    }

    public boolean isBalanced(String stringToCheck) {
        return isBalanced(stringToCheck.toCharArray());
    }
}

package so_q33378870;

public class main {

    private static final String[] tests = {
        //Single - Balanced.
        "()",
        //Single - Unbalanced by missing end.
        "(_",
        //Multiple - Balanced.
        "()[]{}<>",
        //Multiple - Unbalanced by missing beginning.
        "()[]_}<>",
        //Nested - Balanced.
        "([{<>}])",
        //Nested - Unbalanced by missing end.
        "([{<>}_)",
        //Endurance test - Balanced.
        "the_beginning (abcd) divider (a[bc]d) divider (a[b{c}d]e) divider (a[b{c<d>e}f]g) the_end"
    };

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        BalanceChecker checker = new BalanceChecker();
        for (String s : tests) {
            System.out.println("\"" + s + "\" is " + ((checker.isBalanced(s)) ? "BALANCED!" : "UNBALANCED!"));
        }
    }
}