C# 以最佳方式检查算术字符串括号的对称性

我想检查给定的字符串是否如下所示：

(a[i]+{-1}*(8-9))

有效

有效方式：

([]{}()) 

可以，但无效的是：

{([[}))

我正试图通过堆栈来实现这一点。
首先，将这3个支架中的任何一个支架取出，然后反向推压。 第二个堆栈再次推送它，因此如果我有：

(   [   ]   {   }   (   )   )

第一个堆栈获得：

)   ]   }   )

)   }   ]   )

第二个堆栈得到：

)   ]   }   )

)   }   ]   )

现在是逻辑部分

我找到了一个非常难看的解决办法。 理想是什么？（请不要让我发布我的解决方案，因为它是有效的，但它只是凌乱、蹩脚和远离“理想”）

总之，这是我的算术字符串和两个堆栈：

    public static string aritmethic { get; } = "( a[i]+{-1}*(8-9) )";
    Stack<char> original = new Stack<char>();
    Stack<char> temp = new Stack<char>();

希望我对我的问题足够清楚。谢谢！

---

顺便说一句，我对CSharp很新鲜，所以不要对我苛刻

您只需使用单个堆栈和输入字符串的单次传递即可完成所有这一切：

var openers = "([{";
var closers = ")]}";
var brackets = new Stack<char>();
for (int i = 0; i != s.Length; ++i) {
    if (openers.Contains(s[i]))
        brackets.Push(s[i]);
    else if (closers.Contains(s[i])) {
        var opener = openers[closers.IndexOf(s[i])];
        if (brackets.Count == 0 || brackets.Peek() != opener)
            Console.WriteLine("Mismatched '{0}' at {1}", s[i], i);
        else
            brackets.Pop();
    }
}
if (brackets.Count != 0)
    Console.WriteLine("Unmatched '{0}'", brackets.Peek());

var openers=“（[{”；
var closer=“）]}”；
var方括号=新堆栈（）；
对于（int i=0；i！=s.长度；++i）{
if（开启器包含（s[i]））
括号。推（s[i]）；
else if（闭合器包含（s[i]））{
var opener=openers[closer.IndexOf（s[i]）；
if（方括号.Count==0 | |方括号.Peek（）！=opener）
WriteLine（“在{1}处不匹配的{0}”，s[i]，i）；
其他的
括号.Pop（）；
}
}
如果（方括号.Count！=0）
WriteLine（“不匹配的'{0}'，方括号.Peek（））；

这是因为当您遇到一个左括号时，下一个需要匹配的右括号（或另一个创建嵌套范围的左括号）。因此，代码将每个开始括号的新状态推送到堆栈上，当遇到结束括号时，会弹出该状态（检查它们是否匹配）。

static void Main（String[]args）
{
字符串输入=“{（）}”；
布尔成功=真；
HashSet open括号=新的HashSet（）{'（'，{'，['}；
HashSet close括号=新的HashSet（）{'），'}'，']'}；
Stack mystack=新堆栈（）；
for（int i=0；i

算法： 1.创建一个新堆栈！！ 2.遇到开口支架时，将其推到堆栈上。 3.当遇到结束括号时，请检查堆栈顶部的当前元素是否为结束括号的对应括号 括号。如果是，则弹出堆栈的顶部元素。 4.最后检查堆栈中的剩余元素是否为零

---

我不明白你想问什么问题？你有一个难看的解决方案，但它正在发挥作用？那么你在寻找更好的解决方案吗？的确。我的解决方案不是直接处理堆栈的能力。更像是绕过和胡闹。希望你的解决方案在输入时是空的”（a[i]+{-1}*（8-9））”这应该是不正确的。很多情况

var openers = "([{";
var closers = ")]}";
var brackets = new Stack<char>();
for (int i = 0; i != s.Length; ++i) {
    if (openers.Contains(s[i]))
        brackets.Push(s[i]);
    else if (closers.Contains(s[i])) {
        var opener = openers[closers.IndexOf(s[i])];
        if (brackets.Count == 0 || brackets.Peek() != opener)
            Console.WriteLine("Mismatched '{0}' at {1}", s[i], i);
        else
            brackets.Pop();
    }
}
if (brackets.Count != 0)
    Console.WriteLine("Unmatched '{0}'", brackets.Peek());

static void Main(String[] args)
{
    string input = "{()}";
    bool success = true;
    HashSet<char> openBrackets = new HashSet<char>() { '(', '{', '[' };
    HashSet<char> closeBrackets = new HashSet<char>() { ')', '}', ']' };
    Stack<char> mystack = new Stack<char>();
    for (int i = 0; i < input.Length; i++)
    {
        if (openBrackets.Contains(input[i]))
            mystack.Push(input[i]);
        else if (closeBrackets.Contains(input[i])){
            if(mystack.Count == 0)
            {
                success = false;
                break;
            }
            if (input[i] == '}' && mystack.Peek() == '{')
                    mystack.Pop();
            else if (input[i] == ')' && mystack.Peek() == '(')
                    mystack.Pop();
            else if (input[i] == ']' && mystack.Peek() == '[')
                    mystack.Pop();
            else
            {
                success = false;
                break;
            }
        }


    }

    if (mystack.Count == 0 && success)
        Console.WriteLine("Correct Input");
    else Console.WriteLine("Incorrect input");

    Console.ReadKey();
}