递归连接以空字符结尾的字符串

Question

我正在发明需要分析 C++ 代码的面试问题，这些代码使用指针和递归来做一些简单的事情。我尝试以递归方式写strcat()：

size_t mystrlen( const char* str )
{
    if( *str == 0 ) {
        return 0;
    }
    return 1 + mystrlen( str + 1 );
}

void mystrcpy( char* to, const char* from )
{
    if( ( *to = *from ) == 0 ) {
        return;
    }
    mystrcpy( to + 1, from + 1 );
}

void mystrcat( char* to, const char* from )
{
    mystrcpy( to + mystrlen( to ), from );
}

我不喜欢这里的是我有三个函数，而我的 strcat() 不是很递归 - 它只调用其他两个函数一次。有没有办法以某种方式重写它以减少函数的数量，增加递归的使用，但又不牺牲代码的简洁性？

Answer 1

怎么样：

void mystrcat( char* to, const char* from )
{
    if (*to == '\0')
        mystrcpy( to, from );
    else
        mystrcat( to + 1, from );     
 }

Answer 2

我想你已经完成了。您有两个可爱的递归函数，以及对它们的单行调用。

我只能想到一种骇人听闻的方式，甚至可以在一个函数中做到这一点：

void
mystrcat(char* to, const char* from, bool copy_now)
{
    if (!copy_now && *to)
    {
        mystrcat(to+1, from, false);
        return;
    }

    *to = *from;
    if (*to)
        mystrcat(to+1, from+1, true);
}

如果您使用 C++ 并且您将 copy_now 设为默认值为 false 的可选参数，那几乎不会很糟糕。然后调用者可以假装它没有那个额外的状态。

但是，如果问题很难让您在 StackOverflow 上寻求帮助，那么它就很难成为一个合理的面试问题。您可以要求它只是为了试图让人们跳出框框思考，但不要让未能得到好的答案自动失败。

我建议添加另一个可爱的递归问题：求二叉树的深度。

给定以下结构：

typedef struct s_node
{
    struct s_node *pLeft;
    struct s_node *pRight;
} NODE;

写一个函数

int tree_depth(NODE *pNode)

返回树的最大深度。实际上，我曾经在一次面试中被问过这个问题，我认为这正是面试的合适难度。您不想雇用的人会遇到麻烦，而您可能想雇用的人可能会喜欢它。

编辑：我测试了这个函数，发现它有一个错误。此版本已修复错误。

Answer 3

您可以在一个函数中编写：

// pre: to is a string that is zero-initiallized (all chars are '\0')
void mystrcat( char* to, const char* from )
{
   if ( *to ) mystrcat( to+1, from );
   else {
      if (*to = *from) mystrcat( to+1, from+1 );
   }
}

请注意，它是故意丑陋的，它用于两个分支，它在第一个分支中推进to 指针，并在另一个分支中复制值。 if 条件也故意丑陋，因为通常您会将条件中的单个 = 标记为拼写错误，但坚持认为它已启动、运行和测试，以便他们必须自己弄清楚含义。

您可能会考虑的另一件事是添加一个返回语句，例如：

char* mystrcat2( char* to, const char* from )
{
   if ( *to ) return mystrcat2( to+1, from );
   else {
      if ( *to = *from ) return mystrcat2( to+1, from+1 );
      else return to;
   }
}

现在受访者的第二个任务是解释函数在两个字符串上调用时的结果，你可以讨论这个strcat版本的效率与原始版本相比如何，无论是在单字符串连接方面还是在多个连接（查看 Joel Spolsky 的 this article，其中讨论了 Scheimel 绘制算法）。您可以通过strcat 和mystrcat 来要求实现这个功能：

// concatenates a set of strings into a buffer
//
// pre:  to has memory enough to hold all the contents
//       from[i] is a valid C string for all i smaller than n
void mymultiplecat( char* to, const char* from[], int n )
{
   for ( int i = 0; i < n; ++i ) {
      to = mystrcat( to, from[i] );
   }
}

Answer 4

好吧，我真的不明白尝试使 strcat() “尽可能递归”的意义，即使它只是用于面试问题。 strcpy() 只是一个 strlen() + strcat() 并且实现应该反映这一点。如果应聘者提供了您所勾画的解决方案，我会非常高兴 - 他/她表明他/她了解 1. 递归和 2. 使用子例程来实现更复杂的功能。

Answer 5

这是我的例子（优点是它只有一个递归调用）：

char * mystrcat(char *dest, const char *src){
    if(*dest == 0){
        if(*src == 0)   // end of recursion cond
            return dest;
        *dest = *src++; // actual copy
        dest[1]=0;      // zero out dest buf
    }
    mystrcat(dest+1,src); // advance one char
    return dest;
}

这里是粗略的测试代码：

main(){
  char c[]={'a',0,'b','c',0};
  //char c[]={0,'b','c',0};
  mystrcat(c,"xy");
  //mystrcat(c,"");
  puts(c);
}

Answer 6

我想到了另一个答案！

void
mystrcat(char* to, const char* from)
{
    if (*to)
    {
        // keep looking for end of to
        mystrcat(to+1, from);
        return;
    }

    if (*from)
    {
        // make sure we get past first if
        to[1] = '\0';
        // call recursively until end of from found
        mystrcat(to+1, from+1);
        // after call, copy chars on way out
        *to = *from;
    }
}

没有额外的参数来保持状态，它仍然是 O(n)。

不过，我不确定自己能否在工作面试的压力下提出这个想法。

Answer 7

有一次我有一个面试问题，我必须编写一个简单的递归 BSP 树遍历，它是一个完整程序的实际空白函数。

我建议，与发明一个在 C++ 中没有惯用递归解决的问题相比，类似的方法是衡量某人对递归的掌握程度的更好方法。此外，当您运行程序并且他们观察到他们的代码完美运行时，对于入门级申请者来说，这是令人兴奋的。

如果您坚持使用 strcat，我认为如果任务是递归连接从链表中获取的任意数量的字符串可能会更有趣。即使数据复制和字符串长度操作不是递归的，链表的遍历也可能是，而且我认为它会更有趣，因为您实际上可以在向下和向上的过程中进行工作。

Answer 8

你想要递归和简洁？这是我认为兼具这两种品质的东西，而无需深入研究高尔夫球杂草（这并不是说它不丑 - 确实如此）：

char* myStrcat( char* to, char const* from)
{
    if (!*from) return to;

    if (!*to) *to++ = *from++, *to-- = '\0';

    return myStrcat( to+1, from) - 1;
}

请注意，此版本增加了返回目标指针的复杂性（如标准strcat()）。

这是一个更易读的版本，它使用较少的“伪聪明”，如逗号运算符，并在递增后递减以恢复 to 指针（出于某种原因，steveha 的评论促使我这样做）。再看这里的各种答案几乎等同于catwalk's answer：

char* myStrcat( char* to, char const* from)
{
    if (!*from) return to;  // terminal condition, no more chars to concatenate

    if (!*to) {
        // since we're at the end of the 'to' string, 
        //    append char from 'from'
        //    and 'consume' it from `from`
        *to = *from++;
        *(to+1) = '\0';
    }

    return myStrcat( to+1, from) - 1;
}

但是，请不要将我的名字与任何此代码相关联（我声称它是从其他人那里窃取的）。