在C＃中編寫遞歸函數

Question

我需要編寫一個函數來驗證括號是否在字符串中平衡。 每個開括號應該有一個相應的近括號，它們應該正確對應。

例如，對於以下字符串，該函數應返回true：

（if（any？x）sum（/ 1 x））

我說（它還沒有完成）。 （她不聽）

對於以下字符串，該函數應返回false：

:-)

（））（

可選獎金

將解決方案實現為遞歸函數，沒有突變/副作用。

你可以用C＃幫我寫信，因為我是.NET技術的新手。

謝謝。

這是我到目前為止所嘗試的內容。 它適用於將參數作為開括號和近括號發送，但我只是傳遞一個字符串...而且我不應該使用堆棧。

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 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 2

我使用了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;
}

Answer 3

這個遞歸版本怎么樣？

    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;
    }