用 C# 编写递归函数

Question

我需要编写一个函数来验证括号在字符串中是否平衡。每个左括号应该有一个对应的右括号，并且它们应该正确对应。

例如，函数应为以下字符串返回 true：

(if (any?x) sum (/1 x))

我说（还没有完成）。 （她没听）

该函数应为以下字符串返回 false：

:-)

())(

可选奖金

将解决方案实现为没有突变/副作用的递归函数。

由于我是 .NET 技术的新手，请您帮助我使用 C# 编写代码。

谢谢。

这是我迄今为止尝试过的。它适用于将参数作为左括号和右括号发送，但我对仅传递字符串感到困惑......而且我也不应该使用堆栈。

private static bool Balanced(string input, string openParenthesis, string closedParenthesis)
    {

        try
        {
            if (input.Length > 0)
            {
                //Obtain first character
                string firstString = input.Substring(0, 1);

                //Check if it is open parenthesis
                //If it is open parenthesis push it to stack
                //If it is closed parenthesis pop it
                if (firstString == openParenthesis)
                    stack.Push(firstString);
                else if (firstString == closedParenthesis)
                    stack.Pop();

                //In next iteration, chop off first string so that it can iterate recursively through rest of the string
                input = input.Substring(1, input.Length - 1);
               Balanced(input, openParenthesis, closedParenthesis);   //this call makes the function recursive
            }

            if (stack.Count == 0 && !exception)
                isBalanced = true;
        }
        catch (Exception ex)
        {
            exception = true;
        }

        return isBalanced;
    }

Answer 1

这个递归版本怎么样？

    public static bool Balanced(string s)
    {
        var ix = -1;
        return Balanced(s, false, ref ix);
    }

    private static bool Balanced(string s, bool inParens, ref int ix)
    {
        ix++;
        while (ix < s.Length)
        {
            switch (s[ix++])
            {
                case '(':
                    if (!Balanced(s, true, ref ix))
                        return false;
                    break;
                case ')':
                    return inParens;
            }
        }

        return !inParens;
    }

Answer 2

对于这么简单的需求，你不需要使用任何递归方法，只需尝试这个简单的方法，它就像一个魅力：

public bool AreParenthesesBalanced(string input) {
  int k = 0;
  for (int i = 0; i < input.Length; i++) {
      if (input[i] == '(') k++;
      else if (input[i] == ')'){
        if(k > 0)  k--;
        else return false;
      }
  }
  return k == 0;
}

Answer 3

我在每次递归调用中都使用了 startIndex 和增量

  List<string> likeStack = new List<string>();
  private static bool Balanced(string input, string openParenthesis, string closedParenthesis , int startIndex)
{

    try
    {
        if (startIndex < input.Length)
        {
            //Obtain first character
            string firstString = input.Substring(startIndex, 1);

            //Check if it is open parenthesis
            //If it is open parenthesis push it to stack
            //If it is closed parenthesis pop it
            if (firstString == openParenthesis)
                likeStack.Add(firstString);
            else if (firstString == closedParenthesis)
                likeStack.RemoveAt(likeStack.Count -1);

            //In next iteration, chop off first string so that it can iterate recursively through rest of the string
           Balanced(input, openParenthesis, closedParenthesis , startIndex + 1);   //this call makes the function recursive
        }

        if (likeStack.Count == 0 && !exception)
            isBalanced = true;
    }
    catch (Exception ex)
    {
        exception = true;
    }

    return isBalanced;
}