void function(no printing)- reverse a string using recursion

An implementation with tail recursion:

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

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

I think the requirement was in-place reversal.

The only way to do that (I think the OP realises) is to work from the ends and swap 'symmetric' positions. That is swap the first with last, second with second last, etc.

That's fine but we need to realise when we've 'met' in the middle. That's obvious of odd length cases - the two working points meet. For even cases we need to spot the workings 'crossing over'.

That's exactly how reversefill(,) works.

I think this code is an excellent specimen of the strengths and weaknesses of C strings. The main function is fantastically efficient.

But actually has to scan the string twice because C doesn't intrinsically provide a O(1) way of obtaining the length of a string!

You could write the function like

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

But it is a wrong solution because it is not function void reverse( char s[] ); that is a recursive function. It is function void reverse_impl( char s[], size_t n ); that is recursive. But according to your assignment it is function void reverse( char s[] ); that has to be recursive.

So the correct solution is the following.

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

The output is

abcde
edcba

This recursive function uses neither standard function :)