在 C 中使用 return 和 putBack 函数递归地反转字符串

Question

所以作为作业，我需要递归地实现 reverseRec 函数。我不能使用任何循环，但必须在其中使用 putBack 函数，并且该函数需要返回一些东西，这使一切变得不必要地复杂。 所以在递归到达字符串的末尾后，它就返回了。如果例如字符串是“ABC”，然后是 ABC-->BC-->C-->/0-->C-->BC--> A公元前。我的想法是，我以某种方式保存每个返回 recusion 的字符串 (*s) 的开头，并将它们与 putBack 函数一起添加到 CBA。但我认为这是行不通的，因为它是一个递归，这意味着我无法从任何递归深度保存任何东西，因为它会被覆盖，对吧？ 我觉得我错过了一些关于递归和缓冲区如何在 C 中工作的东西，但是 idk。

#include "stdio.h"
#include "stdlib.h"

int length(char *s) {
  int n = 0;
  while(*s != '\0') {
    n++;
    s++;
  }
  return n;
}

void copy(char* s, int n, char* t) {
  int i = 0;
  while(i < n) {
    t[i] = s[i];
    i++;
  }
}

char* putBack(char* s, char c) {
  const int n =  length(s);
  char* r = malloc(sizeof(char) * (n+2));
  copy(s, n, r);
  r[n] = c;
  r[n+1] = '\0';
  return r;
}

char* reverseRec(char *s){     

    if(*s){                   
        reverseRec(s+1);
        s = putBack(s, *(s-1));           //???
    }
    return s;
}


int main() {
printf("%s", reverseRec("ABC"));
}

Answer 1

示例输入字符串“12345”必须变为“54321” 你的教授给了你一个提示。递归将输入字符串分解成更小的部分，然后一个接一个地构建在一起。这意味着输入字符串“12345”的“递归步骤”数量为五个

提示 1：reverseRec( ) 的输入是
输入 1：“12345”
输入 2：“2345”
输入 3：“345”
输入 4：“45”
输入 5：“5”

提示 2：每个 reverseRec( ) 的输出是
输出 1：“54321”
输出 2：“5432”
输出 3：“543”
输出 4：“54”
输出 5：“5”

提示 3：由于 reverseRec() 调用自身，它返回一个值。可以使用该值。
reverseRec 1( 字符串 ) 得到 "5434"
reverseRec 2( string ) 得到 "543" (被调用的 reverseRec3 返回 "543" )
reverseRec 3( string ) 得到 "54" (被调用的 reverseRec4 返回 "54" )
reverseRec 4( string ) 得到 "5" (被调用的 reverseRec5 返回 "5" )
reverseRec 5( string ) 什么也得不到（没有调用下一个 reverseRec 来获取值）

提示 4：现在你得到了一组信息和一个缺失的目标
来自提示 1 的给定信息（输入）：
来自提示 2 的给定信息（输出）：
提示 3 的返回值：

reverseRec 1( string ) 得到“5434”，应该返回“54321”，给定输入字符串“12345”
reverseRec 2( string ) 得到“543”，应该返回“5432”，给定输入字符串“2345”
reverseRec 3( string ) 得到“54”，应该返回“543”，给定输入字符串“345”
reverseRec 4( string ) 得到“5”，应该返回“54”，给定输入字符串“45”
reverseRec 5( string ) 什么都得不到，返回 5，给定输入 "5"

提示 5：缺失的目标
您必须为步骤 4、3、2、1 创建 [应该返回“输出”]
你得到了返回值、输入字符串和 putBack

信息是工作的 80% ;) 现在坐下来测试一些想法，
或者使用调试器一步一步去看看什么时候发生了什么。

反向记录（）{
// 递归魔法

Answer 2

在我看来，您有两个障碍需要克服。第一个是使用putBack() 的递归，第二个是putBack() malloc 在每个递归级别的字符串，您需要释放这些字符串以避免内存泄漏。这是我的解决方案：

char* reverseRec(char* s) {

    if (length(s) > 1) {
        char* r = putBack(reverseRec(s + 1), *s);
        copy(r, length(r), s);
        free(r);
    }

    return s;
}

由于我们正在反转字符串，我们知道副本将始终适合原始字符串。完整代码：

#include <stdio.h>
#include <stdlib.h>

int length(char* s) {
    int n = 0;

    while (*s++ != '\0') {
        n++;
    }

    return n;
}

void copy(char* s, int n, char* t) {
    int i = 0;

    while (i < n) {
        t[i] = s[i];
        i++;
    }
}

char* putBack(char* s, char c) {
    const int n = length(s);
    char* r = calloc(n + 2, sizeof(char));

    copy(s, n, r);
    r[n] = c;
    r[n + 1] = '\0';

    return r;
}

char* reverseRec(char* s) {

    if (length(s) > 1) {
        char* r = putBack(reverseRec(s + 1), *s);
        copy(r, length(r), s);
        free(r);
    }

    return s;
}

int main(int argc, char* argv[]) {

    printf("%s\n", reverseRec(argv[1]));

    return 0;
}

这假定argv[] 字符串是可变的——如果不是，则将其复制到一个新的malloc'd 字符串中。

输出

% ./a.out abcdef
fedcba
%