C# 检查表达式C中是否有平衡圆括号#

希望你做得很好。我一直在与这个代码斗争。我想这一定行得通，但我看不清楚我犯了什么错误（我就像瞎子一样）。
你能帮个忙吗。。。。提前谢谢。 两个字符串都返回FALSE。但首先必须是正确的

using System;
using System.Collections.Generic;
using System.Linq;
using UnityEngine;

public class PatternFinder : MonoBehaviour
{
    public void Check()
    {
        String test_good = "()(){}{}{()}";//this must return TRUE
        String test_bad = "((({}{}))()";//this must return FALSE

        Debug.Log(checkBalanced(test_good));
        Debug.Log(checkBalanced(test_bad));
    }

    public static bool checkBalanced(String check)
    {
        Stack<char> stack = new Stack<char>();
        for (int i = 0; i < check.Length; i++)
        {
            char character = check[i];
            if (character == '[' || character == '{' || character == '(')
                stack.Push(character);
            else if (character == ']' || character == '}' || character == ')')
            {
                if (stack.Any())
                    return false;
                switch (character)
                {
                    case ']':
                        if (stack.Pop() != '[')
                            return false;
                        break;
                    case '}':
                        if (stack.Pop() != '{')
                            return false;
                        break;
                    case ')':
                        if (stack.Pop() != '(')
                            return false;
                        break;
                    default:
                        break;
                }
            }
        }
        if (stack.Any())
            return true;
        return false;
    }
}

使用系统；
使用System.Collections.Generic；
使用System.Linq；
使用UnityEngine；
公共类模式查找器：单一行为
{
公共作废检查（）
{
字符串test_good=“（）（）{}{}{（）}”//必须返回TRUE
String test_bad=“（（{}{}））（）”；//这必须返回FALSE
Log（checkBalanced（test_good））；
Log（checkBalanced（test_bad））；
}
公共静态布尔校验平衡（字符串校验）
{
堆栈=新堆栈（）；
for（int i=0；i

在输入此if语句后，您不需要堆栈.Any（）。这会导致您过早地从函数返回。因为如果堆栈中有任何内容，它就会存在函数，而不会删除任何内容

        else if (character == ']' || character == '}' || character == ')')
        {
            if (stack.Any()) // you don't want this here
                return false; 

在从堆栈中弹出任何内容之前使用stack.Any（）并没有任何作用，因为您希望遍历字符串，直到找到一个不匹配的字符串

相反，您应该有！stack.Any（），因为如果堆栈为空，并且您有一个结束字符，那么它是不平衡的

public static bool checkBalanced(String check)
{
    Stack<char> stack = new Stack<char>();
    for (int i = 0; i < check.Length; i++)
    {
        char character = check[i];
        if (character == '[' || character == '{' || character == '(')
            stack.Push(character);
        else if (character == ']' || character == '}' || character == ')')
        {
            if (!stack.Any()) // if stack is empty and you have a closing character this means that it is unbalanced 
                return false;
            switch (character)
            {
                case ']':
                    if (stack.Pop() != '[')
                        return false;
                    break;
                case '}':
                    if (stack.Pop() != '{')
                        return false;
                    break;
                case ')':
                    if (stack.Pop() != '(')
                        return false;
                    break;
                default:
                    break;
            }
        }
    }
    // it is balanced only if there aren't any left
    if (!stack.Any())
        return true;
    return false;
}

publicstaticboolcheckbalanced（字符串检查）
{
堆栈=新堆栈（）；
for（int i=0；i

在输入此if语句后，您不需要堆栈.Any（）。这会导致您过早地从函数返回。因为如果堆栈中有任何内容，它就会存在函数，而不会删除任何内容

        else if (character == ']' || character == '}' || character == ')')
        {
            if (stack.Any()) // you don't want this here
                return false; 

在从堆栈中弹出任何内容之前使用stack.Any（）并没有任何作用，因为您希望遍历字符串，直到找到一个不匹配的字符串

相反，您应该有！stack.Any（），因为如果堆栈为空，并且您有一个结束字符，那么它是不平衡的

public static bool checkBalanced(String check)
{
    Stack<char> stack = new Stack<char>();
    for (int i = 0; i < check.Length; i++)
    {
        char character = check[i];
        if (character == '[' || character == '{' || character == '(')
            stack.Push(character);
        else if (character == ']' || character == '}' || character == ')')
        {
            if (!stack.Any()) // if stack is empty and you have a closing character this means that it is unbalanced 
                return false;
            switch (character)
            {
                case ']':
                    if (stack.Pop() != '[')
                        return false;
                    break;
                case '}':
                    if (stack.Pop() != '{')
                        return false;
                    break;
                case ')':
                    if (stack.Pop() != '(')
                        return false;
                    break;
                default:
                    break;
            }
        }
    }
    // it is balanced only if there aren't any left
    if (!stack.Any())
        return true;
    return false;
}

publicstaticboolcheckbalanced（字符串检查）
{
堆栈=新堆栈（）；
for（int i=0；i

如果（stack.Any（））{return false；}

看起来可疑。如果遇到

）

和以前的

（

），为什么你会说表达式不平衡呢？另外，你可以自己学习如何调试代码，而不是让我们调试。下面是一篇关于这个主题的流行博文：。

如果（stack.Any（））{return false；}

看起来很可疑。如果遇到

）

并且以前有

（

），为什么你会说表达式不平衡？另外，如果你自己学习如何调试代码而不是让我们调试代码，可能会更有用。下面是一篇关于这个主题的流行博文：。但这一行可能会让你感到困惑