void 函数（不打印）- 使用递归反转字符串

Question

我想用 C 语言编写一个递归函数来反转一个单词。我知道如何打印它，但实际上我不知道如何反转原始单词。 所以，我想编写一个函数来反转一个单词，使用指针，使用 string.h，但必须是 void，不打印，并更改原始单词。函数原型： 无效反向（字符*字符串）； 我能写的是递归的停止项（我不确定它们是否正确）；

if(!string) return; // if the string is empty
if(*(string+1)=='\0' return (*string); // if there is only on char in the string
if(*(string+2))=='\0' // if there are only 2 letters In the strings-swap
temp=(*string);
(*string)= * (string+1);
(*string+1)= temp; // I don't know what to do after..

如果大家可以向我解释该怎么做，那就太好了。 谢谢。

Answer 1

尾递归的实现：

#include <stdio.h>
#include <string.h>

/* function prototypes */
void reverse(char *string);
void reverseWorker(char *string, int start, int end);

int main(int argc, const char *argv[]) {
  char string[] = "Hello, world.";
  printf("string (original) = %s\n", string);
  /*
  reverse(string);

  Or, to reverse each word in the string...
  */

  char *ptr = strtok(string, " ");
  while(ptr != NULL) {
    reverse(ptr);
    ptr = strtok(NULL, " ");
    if(ptr != NULL)
      *(ptr-1)=' ';
  }

  /* the rest is the same */

  printf("string (reversed) = %s\n", string);
  return 0;
}

void reverse(char *string) {
  reverseWorker(string, 0, strlen(string)-1);
}

void reverseWorker(char *string, int start, int end) {
  /* terminal condition */
  if(start>=end)
    return;
  /* swap */
  char temp = string[start];
  string[start]=string[end];
  string[end]=temp;
  /* recursive step */
  reverseWorker(string,start+1,end-1);
}

Answer 2

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

void reversefill(char*const from,char*const to){
    if(from>=to){
        //Nothing to do. Odd lengths get to from==to.
        //Even lengths 'swap over'.
        //Pointer comparison guaranteed legit - in the same array.
        return;
    }
    //Textbook swap.
    //Could use the classic xor swap trick.
    //However that will just confuse in this example.
    const char temp=*from;
    *from=*to;
    *to=temp;

    //Carry on moving our 'work' points closer together from both ends.
    reversefill(from+1,to-1);
}

void reverse(char* str){
    const size_t sz=strlen(str);
    if(sz==0){
        return;//Can't use str-1 - UB.
        //Could head for the door if sz==1 but this is a training example on recursion.
        //So we'll just show it works if from==to.
    }
    reversefill(str,str+sz-1);
}

int main() {
    char*const str="Hello World!";
    char*const rev=malloc(strlen(str)*sizeof(*str));//sizeof not required but good habit

    strcpy(rev,str);

    reverse(rev);

    printf("%s\n",rev);

    free(rev);//Don't listen to smart-arses who say that's unnecessary. 
    //Unless you really need to use the trick...
    //However examples should be the cleanest possible code.

    return EXIT_SUCCESS;
}

我认为要求是就地反转。

做到这一点的唯一方法（我认为 OP 意识到）是从两端开始工作并交换“对称”位置。也就是将第一个与最后一个交换，第二个与倒数第二个交换，等等。

这很好，但我们需要意识到我们什么时候在中间“相遇”了。 这对于奇数长度的情况很明显 - 两个工作点相遇。 即使在某些情况下，我们也需要发现“交叉”的工作原理。

这正是reversefill(,) 的工作原理。

我认为这段代码很好地体现了 C 字符串的优缺点。 main 函数非常高效。

但实际上必须扫描字符串两次，因为 C 本身并不提供 O(1) 获取字符串长度的方法！

Answer 3

你可以这样写函数

void reverse( char s[] )
{
    reverse_impl( s, strlen( s ) );
}

void reverse_impl( char s[], size_t n )
{
    if ( !( n < 2 ) )
    {
        char c = s[0];
        s[0] = s[n-1];
        s[n-1] = c;
        reverse_impl( s + 1, n - 2 );
    }
}

但这是一个错误的解决方案，因为它不是函数void reverse( char s[] ); 是一个递归函数。函数void reverse_impl( char s[], size_t n ); 是递归的。但根据您的任务，函数void reverse( char s[] ); 必须是递归的。

所以正确的解决方案如下。

#include <stdio.h>

void reverse( char s[] )
{
    if ( *s  )
    {
        char *p = s;
        char c;

        do
        {
                    c = *p;
                    *p = *( p + 1 );
                    *( p + 1 ) = c; 
        } while ( *p++ );

        reverse( s );

        c = *p;
        *p = *( p - 1 );
        *( p - 1 ) = c;
    }
}


int main( void ) 
{
    char s[] = "abcde";

    puts( s );
    reverse( s );
    puts( s );

    return 0;
}

输出是

abcde
edcba

这个递归函数不使用标准函数:)