C# 测试括号是否平衡，（a{[]b（{}}}c）[]返回false，但应为true

这段代码的目的是测试每组字符串中的括号是否平衡。有12个测试，必须全部通过，目前，我有11个工作，但最后一个不会工作。 目前，我有三个静态bool，它们澄清了什么是括号，以及它们是否匹配

 private static bool IsOpeningParenthesis(char c)
        {
            return c == '(' || c == '[' || c == '{';
        }

private static bool IsClosingParenthesis(char c)
        {
            return c == ')' || c == ']' || c == '}';
        }

private static bool Matches(char a, char b)
        {
            return (a == '(' && b == ')') || (a == '[' && b == ']') ||
                (a == '{' && b == '}');
        }

下面，我有一个bool，它实际上检查它们是否匹配，这就是我的错误所在

public static bool IsBalanced(string s)
        {
            Stack<char> myStack = new Stack<char>();

            foreach (char c in s)
            {
                if (IsOpeningParenthesis(c))
                {
                    myStack.Push(c);
                }
                if (IsClosingParenthesis(c))
                {
                    if (myStack.Count == 0) //takes care of closing parenthesis before adding char d
                    {
                        return false;
                    }
                    char d =  myStack.Pop();
                    if (c == d)
                    {
                        return true;
                    }
                    else
                    {
                        myStack.Push(d);
                        return false;
                    }   
                }
            }
            if(myStack.Count == 0)
            {
                return true;
            }
            else
            {
                return false;
            }

        }

下面是所有测试的完整文件

/* ParenthesisMatcherTests.cs
 * Author: Rod Howell
 */
using NUnit.Framework;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Ksu.Cis300.Parentheses;

namespace Ksu.Cis300.Parentheses.Tests
{
    /// <summary>
    /// A unit test class for the class library Ksu.Cis300.Parentheses.
    /// </summary>
    [TestFixture]
    public class ParenthesisMatcherTests
    {
        /// <summary>
        /// Checks the empty string, which is balanced.
        /// </summary>
        [Test, Timeout(1000)]
        public void TestAEmptyString()
        {
            Assert.That(ParenthesisMatcher.IsBalanced(""), Is.True);
        }

        /// <summary>
        /// Checks the string "abcdefg", which is balanced.
        /// </summary>
        [Test, Timeout(1000)]
        public void TestBNoParentheses()
        {
            Assert.That(ParenthesisMatcher.IsBalanced("abcdefg"), Is.True);
        }

        /// <summary>
        /// Checks the string "[", which is not balanced.
        /// </summary>
        [Test, Timeout(1000)]
        public void TestCOpeningParenthesis()
        {
            Assert.That(ParenthesisMatcher.IsBalanced("["), Is.False);
        }

        /// <summary>
        /// Checks the string ")", which is not balanced.
        /// </summary>
        [Test, Timeout(1000)]
        public void TestDClosingParenthesis()
        {
            Assert.That(ParenthesisMatcher.IsBalanced(")"), Is.False);
        }

        /// <summary>
        /// Tests the string "{{}", which is not balanced.
        /// </summary>
        [Test, Timeout(1000)]
        public void TestEMissingClose()
        {
            Assert.That(ParenthesisMatcher.IsBalanced("{{}"), Is.False);
        }

        /// <summary>
        /// Tests the string "[[]", which is not balanced.
        /// </summary>
        [Test, Timeout(1000)]
        public void TestEExtraClose()
        {
            Assert.That(ParenthesisMatcher.IsBalanced("[]]"), Is.False);
        }

        /// <summary>
        /// Tests the string "[}", which is not balanced.
        /// </summary>
        [Test, Timeout(1000)]
        public void TestEMismatch()
        {
            Assert.That(ParenthesisMatcher.IsBalanced("[}"), Is.False);
        }

        /// <summary>
        /// Tests the string "[}]", which is not balanced.
        /// </summary>
        [Test, Timeout(1000)]
        public void TestEMismatch2()
        {
            Assert.That(ParenthesisMatcher.IsBalanced("[}]"), Is.False);
        }

        /// <summary>
        /// Tests the string "(a{[]b({})}c)[]", which is balanced.
        /// </summary>
        [Test, Timeout(1000)]
        public void TestFLongMatch()
        {
            Assert.That(ParenthesisMatcher.IsBalanced("(a{[]b({})}c)[]"), Is.True);
        }

        /// <summary>
        /// Tests the string "(a{[]b({})}c)[](", whose last parenthesis is not matched.
        /// </summary>
        [Test, Timeout(1000)]
        public void TestFLongMissingClose()
        {
            Assert.That(ParenthesisMatcher.IsBalanced("(a{[]b({})}c)[]("), Is.False);
        }

        /// <summary>
        /// Tests the string "(a{[]b({})}c)[]())", whose last parenthesis is not matched.
        /// </summary>
        [Test, Timeout(1000)]
        public void TestFLongExtraClose()
        {
            Assert.That(ParenthesisMatcher.IsBalanced("(a{[]b({})}c)[]())"), Is.False);
        }

        /// <summary>
        /// Tests the string "(a{[]b({})}c}[]", whose first character is paired with the last '}', and
        /// hence is mismatched.
        /// </summary>
        [Test, Timeout(1000)]
        public void TestFLongMismatch()
        {
            Assert.That(ParenthesisMatcher.IsBalanced("(a{[]b({})}c}[]"), Is.False);
        }
    }
}

/*圆括号matchertests.cs
*作者：罗德·豪厄尔
*/
使用NUnit.Framework；
使用制度；
使用System.Collections.Generic；
使用System.Linq；
使用系统文本；
使用System.Threading.Tasks；
使用Ksu.Cis300.括号；
命名空间Ksu.Cis300.contracles.Tests
{
/// 
///类库Ksu.Cis300.contracles的单元测试类。
/// 
[测试夹具]
公共类括号匹配测试
{
/// 
///检查平衡的空字符串。
/// 
[测试，超时（1000）]
公共无效TestEmptyString（）
{
Assert.That（括号匹配器.IsBalanced（“”），Is.True）；
}
/// 
///检查平衡的字符串“abcdefg”。
/// 
[测试，超时（1000）]
公共无效测试不透明度（）
{
Assert.That（括号ismatcher.IsBalanced（“abcdefg”），Is.True）；
}
/// 
///检查未平衡的字符串“[”。
/// 
[测试，超时（1000）]
公共void testCopening括号（）
{
Assert.That（括号匹配器.IsBalanced（“[”），Is.False）；
}
/// 
///检查未平衡的字符串“）”。
/// 
[测试，超时（1000）]
public void testdclosingchordinas（）
{
Assert.That（括号匹配器.IsBalanced（“）”），Is.False）；
}
/// 
///测试未平衡的字符串“{}”。
/// 
[测试，超时（1000）]
public void TestEMissingClose（）
{
Assert.That（括号匹配器.IsBalanced（{{}”），Is.False；
}
/// 
///测试未平衡的字符串“[]”。
/// 
[测试，超时（1000）]
公营机构
{
Assert.That（括号匹配器.IsBalanced（[]]），Is.False）；
}
/// 
///测试未平衡的字符串“[}”。
/// 
[测试，超时（1000）]
公营机构（
{
Assert.That（括号匹配器.IsBalanced（[}），Is.False）；
}
/// 
///测试未平衡的字符串“[}]”。
/// 
[测试，超时（1000）]
public void testematch2（）
{
Assert.That（括号匹配器.IsBalanced（“[}]”），Is.False）；
}
/// 
///测试平衡的字符串“（a{[]b（{}}}c）[]”。
/// 
[测试，超时（1000）]
public void TestFLongMatch（）
{
Assert.That（括号匹配器.IsBalanced（（（a{[]b（{}}}}c）[]））为.True）；
}
/// 
///测试字符串“（a{[]b（{}）}c）[[]（”，其最后一个括号不匹配。
/// 
[测试，超时（1000）]
public void TestFLongMissingClose（）
{
Assert.That（括号匹配器.IsBalanced（（（a{[]b（{}}}}c）[]（“”），Is.False）；
}
/// 
///测试字符串“（a{[]b（{}}}c）[[]），其最后一个括号不匹配。
/// 
[测试，超时（1000）]
public void TestFLongExtraClose（）
{
Assert.That（括号匹配器.IsBalanced（（（a{[]b（{}}}}c）[]c（））是.False）；
}
/// 
///测试字符串“（a{[]b（{}）}c}[]”，其第一个字符与最后一个“}”配对，并
///因此是不匹配的。
/// 
[测试，超时（1000）]
public void TestFLongMismatch（）
{
Assert.That（括号匹配器.IsBalanced（（（a{[]b（{}}}}c}[]））为.False）；
}
}
}

当我通过调试器运行特定测试时，代码将运行并遍历字符串，直到到达第一个结束括号。 一旦结束括号起作用，开始和结束括号从测试中移除，程序停止返回false。但是它应该继续通过字符串并返回True。我真的对这段代码感到迷茫，因为其他与此非常相似的匹配字符串通过了测试，并且在第一次完形填空后没有退出ng点

---

如果您有任何关于如何解决此问题的建议，我们将不胜感激。如果需要其他帮助，请告诉我，我已尝试尽可能多地提供信息。

从代码来看，我认为问题在于您的

IsBalanced

方法在遇到closi时立即返回

false

插入括号

在代码中，当遇到右括号时，有以下选项：

堆栈上没有项目：

返回false

堆栈上的第一项是相同的右括号（这是不可能的）：

returntrue

返回false

要解决此问题，您可能需要使用

Matches

方法检查右括号是否与从堆栈中弹出的字符匹配：

public static bool IsBalanced(string input)
{
    var stack = new Stack<char>();

    foreach (var chr in input)
    {
        if (IsOpeningParenthesis(chr))
        {
            stack.Push(chr);
        }
        else if (IsClosingParenthesis(chr))
        {
            if (stack.Count == 0) return false;
            if (!Matches(stack.Pop(), chr)) return false;
        }
    }

    return stack.Count == 0;
}

公共静态bool是平衡的（字符串输入）
{
var stack=新堆栈（）；
foreach（输入中的var chr）
{
if（等排烃芳烃（chr））
{
堆栈推送（chr）；
}
else if（不闭合括号（chr））
{
if（stack.Count==0）返回false；
如果（！Matches（stack.Pop（），chr））返回false；
}
}
返回stack.Count==0；
}

我至少有一个bug

public static bool IsBalanced(string input)
{
    var stack = new Stack<char>();

    foreach (var chr in input)
    {
        if (IsOpeningParenthesis(chr))
        {
            stack.Push(chr);
        }
        else if (IsClosingParenthesis(chr))
        {
            if (stack.Count == 0) return false;
            if (!Matches(stack.Pop(), chr)) return false;
        }
    }

    return stack.Count == 0;
}