C#检查表达式是否有效

表达方式：

“（a[i]+{-1}*（8-9））”

应该返回true，因为这样编写语法是有效的。每个左括号都在正确的位置有一个右闭合器，所有括号都位于合法位置。
我试图通过一个堆栈来实现这一点，我知道我错在哪里，但我想知道解决这个问题的相关方法。 谢谢！
我可怜的错误代码：

string expression=“（a[i]+{-1}*（8-9））”；
Stack expStack=新堆栈（）；
List rightBracketsHolder=新列表（）；
for（int i=0；i

此代码将解决您的问题-

static void Main(string[] args)
    {
        bool error = false;
        var str = "( a[i]+{-1}*(8-9) )";
        Stack<char> stack = new Stack<char>();
        foreach (var item in str.ToCharArray())
        {
            if (item == '(' || item == '{' || item == '[')
            {
                stack.Push(item);
            }
            else if(item == ')' || item == '}' || item == ']')
            {
                if (stack.Peek() != GetComplementBracket(item))
                {
                    error = true;
                    break;
                }
            }
        }

        if (error)
            Console.WriteLine("Incorrect brackets");
        else
            Console.WriteLine("Brackets are fine");
        Console.ReadLine();
    }

    private static char GetComplementBracket(char item)
    {
        switch (item)
        {
            case ')':
                return '(';
            case '}':
                return '{';
            case ']':
                return '[';
            default:
                return ' ';
        }
    }

static void Main（字符串[]args）
{
布尔误差=假；
var str=“（a[i]+{-1}*（8-9））”；
堆栈=新堆栈（）；
foreach（str.ToCharArray（）中的变量项）
{
如果（项目=='（'| |项目=='{'| |项目=='['）
{
堆栈。推送（项目）；
}
如果（item=='）'| | item=='}'| | item==']'），则为else
{
if（stack.Peek（）！=GetComplementBracket（项目））
{
错误=真；
打破
}
}
}
如果（错误）
Console.WriteLine（“不正确的括号”）；
其他的
控制台。WriteLine（“括号很好”）；
Console.ReadLine（）；
}
私有静态字符（字符项）
{
开关（项目）
{
案例“）”：
返回“（”；
案例“}”：
返回“{”；
案例']'：
返回“[”；
违约：
返回“”；
}
}

此代码将解决您的问题-

static void Main(string[] args)
    {
        bool error = false;
        var str = "( a[i]+{-1}*(8-9) )";
        Stack<char> stack = new Stack<char>();
        foreach (var item in str.ToCharArray())
        {
            if (item == '(' || item == '{' || item == '[')
            {
                stack.Push(item);
            }
            else if(item == ')' || item == '}' || item == ']')
            {
                if (stack.Peek() != GetComplementBracket(item))
                {
                    error = true;
                    break;
                }
            }
        }

        if (error)
            Console.WriteLine("Incorrect brackets");
        else
            Console.WriteLine("Brackets are fine");
        Console.ReadLine();
    }

    private static char GetComplementBracket(char item)
    {
        switch (item)
        {
            case ')':
                return '(';
            case '}':
                return '{';
            case ']':
                return '[';
            default:
                return ' ';
        }
    }

static void Main（字符串[]args）
{
布尔误差=假；
var str=“（a[i]+{-1}*（8-9））”；
堆栈=新堆栈（）；
foreach（str.ToCharArray（）中的变量项）
{
如果（项目=='（'| |项目=='{'| |项目=='['）
{
堆栈。推送（项目）；
}
如果（item=='）'| | item=='}'| | item==']'），则为else
{
if（stack.Peek（）！=GetComplementBracket（项目））
{
错误=真；
打破
}
}
}
如果（错误）
Console.WriteLine（“不正确的括号”）；
其他的
控制台。WriteLine（“括号很好”）；
Console.ReadLine（）；
}
私有静态字符（字符项）
{
开关（项目）
{
案例“）”：
返回“（”；
案例“}”：
返回“{”；
案例']'：
返回“[”；
违约：
返回“”；
}
}

当关闭发生时，您需要从堆栈中弹出内容。请尝试以下代码。它将在堆栈上推送一个大括号/方括号/圆括号，然后第一件事情将通过相应的关闭从堆栈中弹出。否则无效。如果遇到关闭时堆栈上没有打开，则无效。如果当您完成时，您有任何额外的打开，这是无效的

我还使用了switch语句而不是if语句，因为我认为它更容易阅读

using System;
using System.Collections.Generic;

public class Program
{
   public static void Main()
   {
      string expression = "( a[i]+{-1}*(8-9) ) ";
      bool stackResult = checkValidity(expression);

      if (stackResult)
         Console.WriteLine("Expression is Valid.");
      else
         Console.WriteLine("\nExpression is not valid.");
   }

   private static bool checkValidity(string expression)
   {
      Stack<char> openStack = new Stack<char>();
      foreach (char c in expression)
      {
         switch (c)
         {
            case '{':
            case '(':
            case '[':
               openStack.Push(c);
               break;
            case '}':
               if (openStack.Count == 0 || openStack.Peek() != '{')
               {
                  return false;
               }
               openStack.Pop();       
               break;
            case ')':
               if (openStack.Count == 0 || openStack.Peek() != '(')
               {
                  return false;
               }
               openStack.Pop();       
               break;
            case ']':
               if (openStack.Count == 0 || openStack.Peek() != '[')
               {
                  return false;
               }
               openStack.Pop();       
               break;
            default:
               break;
         }
      }
      return openStack.Count == 0;
   }
}

使用系统；
使用System.Collections.Generic；
公共课程
{
公共静态void Main（）
{
字符串表达式=“（a[i]+{-1}*（8-9））”；
bool stackResult=checkValidity（表达式）；
if（stackResult）
WriteLine（“表达式有效”）；
其他的
Console.WriteLine（“\n表达式无效”）；
}
私有静态bool checkValidity（字符串表达式）
{
Stack openStack=新堆栈（）；
foreach（表达式中的字符c）
{
开关（c）
{
案例“{”：
格“（”：
案例“[”：
openStack.Push（c）；
打破
案例“}”：