反向查找的递归函数

Question

char是递归函数。它不应该有任何l

Answer 1

递归不使用循环。

因此，如果您的函数名为rfind（...），那么在rfind中您必须完成以下所有3项：

• 终止而未查找 - 确定您已到达str的开头，然后使用nullptr退出

• 以find结束 - 在str中的某个位置识别'ch'，然后退出返回位置（char *）

• 继续搜索 - 通过递归调用rfind（...），并返回递归调用返回的值。

---

编辑 - 只是为了好玩，这里有一个3参数rfind我认为更具可读性

注意：没有循环，退出情况和尾递归。

// find _last_ occurrance of ch in str, starting at indx
char*  rfind(char*  str,  char ch, int indx)
{
   // Req 1: terminate when not found, return nullptr
   if(indx < 0)       return (nullptr);  

   // Req 2: terminate when found, return char*
   if(ch == str[indx]) return(&str[indx]) 

   // Req 3: continue search, return search results
   return ( rfind (str, ch, (indx-1)) );    // keep looking
}

[删除 - 3参数rfind用法]

---

编辑 - 要完成此版本，我提供以下内容。结果包括

a）2参数rfind，

b）尾递归，

c）一些测试代码

我以随意的阅读器格式呈现以下内容。您必须添加前向声明或适当地重新安排代码才能编译。

test_rfind（）的使用：

请注意，test_rfind（）有2个参数传递给rfind（）

int t122()
{
    char str[] = "t123abcdefg*o4";

    size_t strSize = strlen(str);
    std::cout << "\n       strSize = " << strSize << "            " << (void*)str
              << "\n       01234567890123" << std::endl;

    for (size_t i = 0; i < strSize; ++i) {
       test_rfind(str, str[i]);
    }
    test_rfind(str, 'z');
    test_rfind(str, '0');  // digit '0'
    test_rfind(str, 'K');
    // ...
 }

test_rfind调用rfind（）， 并且还屏蔽了null str和null tgt以为测试用户提供反馈：

void test_rfind(char* str, char tgt)
{
   do // not part of the recursion, not really a loop, just a test simplification
   {
      if (0 == str) { std::cout << "       str is null " << std::endl;  break; }

      // ===================================================================

      char* pos = rfind(str, tgt);  // 2 parameter invocation - see below

      // ===================================================================

      if (nullptr == pos) {
         std::cout << "rfind('" << std::setw(14) << str
                << "', '" << tgt << "') :           "
                   << "  char '" << tgt
                   << "' not found" << std::endl;
         break;
      }

      // else found
      std::cout << "rfind('" << std::setw(14) << str
                << "', '" << tgt << "') = "
                << (void*)pos
                << std::setw(20) << pos
                << "    last '"  << pos[0]
                << "' at indx: " << (pos - str) << std::endl;
   }while(0);
}

这是你需要的2个参数rfind（）。

惊喜！它只是做了一些验证，然后使用现有的3参数rfind（）。

// two parameter
char*  rfind(char*  str,  char tgt)
{
   // pre-validation
   if (0 == str) return(nullptr); // one null check here, rather than 'inside' recursion

   // pre-validation - tbr: check range (0 <= char <= 127)
   // allow (0 == tgt): a char can be 0

   // now use the 'just for fun' 3 parameter rfind
   return ( rfind(str, tgt, strlen(str)) );  // use tail recursion
}

我发现在递归的过程中，这种“中间步骤”处理了几个前（有时是后）验证。这样可以防止这些事情使实际的递归函数复杂化。

3参数rfind（）接近这个答案的开头，并且不加改变地使用。

猜猜是什么 - 它提供了一个通常必要的功能：在字符串中查找最后一个目标字符，但是你可以在字符串中的任何地方开始搜索。这样，如果你的字符串有2个tgt字符 - 你使用2参数rfind（）找到最后一个ch，然后使用第3个参数找到tgt之前的tgt（而不是缩短str）。

注意：C ++允许两个函数在其签名唯一时具有相同的标识符。因此，2个参数和3个参数版本共享名称“rfind（）”。

测试结果：

       strSize = 14            0xbff8f4bd
       01234567890123
rfind('t123abcdefg*o4', 't') = 0xbff8f4bd      t123abcdefg*o4    last 't' at indx: 0
rfind('t123abcdefg*o4', '1') = 0xbff8f4be       123abcdefg*o4    last '1' at indx: 1
rfind('t123abcdefg*o4', '2') = 0xbff8f4bf        23abcdefg*o4    last '2' at indx: 2
rfind('t123abcdefg*o4', '3') = 0xbff8f4c0         3abcdefg*o4    last '3' at indx: 3
rfind('t123abcdefg*o4', 'a') = 0xbff8f4c1          abcdefg*o4    last 'a' at indx: 4
rfind('t123abcdefg*o4', 'b') = 0xbff8f4c2           bcdefg*o4    last 'b' at indx: 5
rfind('t123abcdefg*o4', 'c') = 0xbff8f4c3            cdefg*o4    last 'c' at indx: 6
rfind('t123abcdefg*o4', 'd') = 0xbff8f4c4             defg*o4    last 'd' at indx: 7
rfind('t123abcdefg*o4', 'e') = 0xbff8f4c5              efg*o4    last 'e' at indx: 8
rfind('t123abcdefg*o4', 'f') = 0xbff8f4c6               fg*o4    last 'f' at indx: 9
rfind('t123abcdefg*o4', 'g') = 0xbff8f4c7                g*o4    last 'g' at indx: 10
rfind('t123abcdefg*o4', '*') = 0xbff8f4c8                 *o4    last '*' at indx: 11
rfind('t123abcdefg*o4', 'o') = 0xbff8f4c9                  o4    last 'o' at indx: 12
rfind('t123abcdefg*o4', '4') = 0xbff8f4ca                   4    last '4' at indx: 13
rfind('t123abcdefg*o4', 'z') :             char 'z' not found
rfind('t123abcdefg*o4', '0') :             char '0' not found
rfind('t123abcdefg*o4', 'K') :             char 'K' not found

---

最近我对递归代码的-O3优化印象非常深刻。

• 在一些尾递归中，编译器完全删除了递归调用并返回，因为没有发生堆栈溢出的证据，在-O0编译时，可执行文件总是崩溃。

• 在至少一个可重复的测试中，得到的完全优化的递归实现比相应的完全优化的循环实现快50％。

Answer 2

这是一个非常简单的递归实现。可悲的是，它不是尾递归的。

全面实施：

char *rfind(char* str, char ch) { 
     if (*str == '\0')
         return NULL; 
     char * pos = rfind(str + 1, ch);
     if (pos != NULL)
         return pos;
     if (*str == ch)
         return str;
     return NULL;
}

基本案例：str是一个零字符串：

     if (*str == '\0')
         return NULL; 

递归呼叫：

     char * pos = rfind(str + 1, ch);

确定我们是否需要字符串的其余部分或当前位置的结果：

     if (pos != NULL)
         return pos;
     if (*str == ch)
         return str;
     return NULL;