Question

我想知道是否有办法检查你是否正在进行一系列递归调用的第一次递归调用。

我正在研究一个功能，测试输入是否是回文。在最后一次递归调用结束后，输入字符串将更改为与原始调用相反。现在我要做的就是将结果与原始结果进行比较。但是当达到基本情况时，我不再能够访问我在else语句中创建的原始字符串的副本。

我的想法是在else语句下比较palCopy和palCheck，但问题是程序会在每次递归调用期间检查这个，当我只想在控制时检查它返回原来的递归调用。只有在将控制权返回到原始递归调用时才有条件地比较palCopy和palCheck吗？

void isAPalindrome(MyString palCheck, int bound1, int bound2)
{

    if (bound1 >= bound2)
    {
        cout << palCheck;
    }
    else
    {
        MyString palCopy = palCheck;  // make a copy of the original argument so as not to alter it
        char temp = palCopy[bound1];
        palCopy[bound1] = palCopy[bound2];
        palCopy[bound2] = temp;
        isAPalindrome(palCopy, bound1 + 1, bound2 - 1); 
    }

Answer 1

通常，您可以通过执行以下操作来跟踪递归深度：

void recurse(int value, const int depth=0)
{
     recurse(value, depth+1); 
}

对于在任何给定点记录递归深度的每个调用，都使用一个额外的变量。

Answer 2

我不会这样解决这个问题，但不要紧。执行此类操作的一般方法是将递归移动到需要额外参数的辅助函数中：

static void 
is_palindrome_internal(string palCheck, int bound1, int bound2,
                       bool outermost)
{
   ...
   is_palindrome_internal(..., false);
   ...
}

void
is_palindrome(string palCheck, int bound1, int bound2)
{
   is_palindrome_internal(palCheck, bound1, bound2, true);
}

只有当前调用位于最外层时，outermost才会成立。这种方法的优点还在于您可以隐藏公共API中的bound1和bound2参数（当然，如果您不希望对子字符串进行操作，请执行此操作）。

void
is_palindrome(string palCheck)
{
    is_palindrome_internal(palCheck, 0, palCheck.length(), true);
}

Answer 3

您已经将一个字符串副本作为arg传递。您还可以传递对原始字符串的引用，以便所有级别的递归都可以访问它们。

void isAPalindrome(MyString palCheck, int bound1, int bound2 , const MyString& original )
{
//Do stuff

     isAPalindrome(palCopy, bound1 + 1, bound2 - 1,original); 
}

Answer 4

C ++没有原始的方法来知道你是否在第一次递归。但是你可以使用level变量来计算递归深度。类似的东西：

void isAPalindrome(MyString palCheck, int bound1, int bound2, int level=0)
{
    if (bound1 >= bound2)
        cout << palCheck;
    else
    {
        MyString palCopy = palCheck;
        char temp = palCopy[bound1];
        palCopy[bound1] = palCopy[bound2];
        palCopy[bound2] = temp;
        isAPalindrome(palCopy, bound1 + 1, bound2 - 1, level+1);
        if (level == 0)
            // You are in the first recursion call
    }
}

Answer 5

我会使用本地结构，以便is_palindrome()只接受一个参数：

bool is_palindrome(const std::string& s) 
{
   struct local
   {
      static bool is_palin(const std::string& s, int l, int h) 
      {
         return l>= h?true:(s[l] == s[h]? is_palin(s,l+1,h-1):false);
      }
   };
   return local::is_palin(s, 0, s.size() - 1);
}

在线演示：http://www.ideone.com/o1m5C

以您想要的方式使用和修改它。

Answer 6

将其作为一个单独的功能：

void isAPalindromeHelper(MyString& palCheck, int bound1, int bound2)
{
    if (bound1 >= bound2)
    {
        cout << palCheck;
    }
    else
    {
        char temp = palCopy[bound1];
        palCopy[bound1] = palCopy[bound2];
        palCopy[bound2] = temp;
        isAPalindromeHelper(palCopy, bound1 + 1, bound2 - 1); 
    }
}
void isAPalindrome(MyString palCheck)
{
    MyString palCopy = palCheck;  
    isAPalindromeHelper(palCheck, 0, palCheck.size()); 
    if (palCopy == palCheck)
        //newstuff here
}

一种测试你是否在第一次运行几个递归调用c ++的方法

6 个答案: