一种测试您是否第一次运行多个递归调用 C++ 的方法

a way to test if you're on the first run of several recursive calls c++

本文关键字：递归 调用 C++ 方法 运行 第一次 一种 测试 是否      更新时间：2023-10-16

我想知道是否有一种方法可以检查您是否处于一系列递归调用的第一个递归调用

我正在研究一个函数，该函数可以测试输入是否是回文。在最后一次递归调用结束后，输入字符串被更改为与原始字符串相反的字符串。现在我要做的就是将结果与原始结果进行比较。但是当达到基准情况时，我就不能再访问我在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); 
    }

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

一般情况下，你可以这样跟踪递归深度:

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

这是使用一个额外的变量来为每个调用记录递归的深度在任何给定的点。

我不会这样解决这个问题，但没关系。实现这类操作的一般方法是将递归移到一个接受额外参数的辅助函数中:

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

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

void isAPalindrome(MyString palCheck, int bound1, int bound2 , const MyString& original )
{
//Do stuff
     isAPalindrome(palCopy, bound1 + 1, bound2 - 1,original); 
}

我将使用一个局部结构体，这样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

使其成为一个单独的函数:

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
}
相关文章：