Reverse a linked list using recursion technique in C

The head of the reversed list is equal to the head of the reversed List starting with restOfElements (because the original headref has to become tha last element of the reversed list). So storing the result of the recussive call should do (as Jim has already suggested in his comment):

...
headref = reverseRecursive(restOfElements);  
firstElement->next->next  = firstElement;
firstElement->next  = NULL;          
/* headref = restOfElements; that's wrong */    
return headref; 

Thanks everyone. I have modified it little bit and it works now. Let me know your comments. new_head is a global variable.

S *reverseRecursive(S *headref)
 {
  S *firstElement   = NULL;
  S *restOfElements = NULL;

  if (headref==NULL)
    {
    return ;
    }
    firstElement = headref;


   if (headref->next == NULL)
      return headref;   
   else
    restOfElements = headref->next;


   reverseRecursive(restOfElements);

   firstElement->next->next  = firstElement;

   firstElement->next  = NULL;          

   if(new_head == NULL ) //just dont take it ervery time
      new_head = restOfElements;

   return new_head; 

  }

Probably closer.

S *reverseRecursive(S *headref)
 {
  S *firstElement   = NULL;
  S *restOfElements = NULL;
  S *new_head = NULL;
  if (headref==NULL)
    {
    return ;
    }
  firstElement = headref;
  restOfElements = headref->next;
  if (restOfElements == NULL)
       return headref;   
  new_head = reverseRecursive(restOfElements); 
  restOfElements->next = new_head;           
  return restOfElements;
} 

$ gcc -std=c99 -Wall -Wextra reverse.c

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

typedef struct list {
  struct list* next;
  int data;
} S;

void print_list(S* list) {
  if (list == NULL) { printf("NULL\n"); return; }
  printf("%d ", list->data);
  print_list(list->next);
}

S* reverse_aux(S* list, S* tail) {
  // invalid arg
  if (list == NULL) { return NULL; }

  // base case
  if (list->next == NULL) {
    list->next = tail;
    return list;
  }

  // general case
  S* tmp = list->next;
  list->next = tail;

  return reverse_aux(tmp, list);
}

S* reverse(S* list) { return reverse_aux(list, NULL); }

int main(int argc, char* argv[]) {
  // build a list with which to test
  S a[10];
  for (unsigned i = 0; i < sizeof(a)/sizeof(S); ++i) {
    a[i].data = i;
    a[i].next = &a[i+1];
  }
  a[sizeof(a)/sizeof(S) - 1].next = NULL;
  S* list = &a[0];

  print_list(list);
  list = reverse(list);
  print_list(list);

  return 0;
}

Actually, since reverse is destructive (it mutates its argument), a better interface design would probably be

void reverse(S** plist);
reverse(&list);

So there's two ways to reverse a list in place recursively.

First, some setup. Let's make it easy to load linked lists of strings and print them, so we can make sure this stuff works:

// linked_list.c
#include <stdio.h>
#include <stdlib.h>

// a linked lis of strings
typedef struct S {
  struct S * next;
  char * val;
} S;

// print out the list
void showS(char * const name, S * head) {
  printf("%s: (", name);
  while (head){
    printf(" ");
    printf("%s",head->val);
    head = head->next;
    printf( "%c", head ? ',' : ' ' );
  }
  printf(")\n");
}

// convert an array of strings into a linked list of strings
S * mkS(int n, char ** args) {
  S * head = NULL;

  if (n > 0 && (head = calloc(n, sizeof(S)))){
    S * curr = head - 1;

    while (n-- > 0) {
      curr++;
      curr->val = *args++;
      curr->next = curr + 1;
    }
    curr->next = NULL;
  }

  return head;
}

One way of reversing the list involves passing back the new head of the list once we find it. We don't need it locally (since we're just moving the current element to the new end), but we'll need it so that the caller has a pointer to the head of the list once we're done.

// reverse a list one way
S * revS1( S * const head ){
  if (head && head->next) {
    S * const new_head = revS1( head->next );
    head->next->next = head;
    head->next = NULL;
    return new_head;
  } else {
    return head;
  }
}

Another way takes a pointer to a pointer. The only difference is that we don't need to return anything, since we're directly modifying a variable the caller has. I prefer this calling method since it's much clearer that we're modifying the list, not returning a copy. It's also harder for the caller to accidentally loose the pointer to the new head this way.

// reverse a list another way
void revS2( S ** phead ){
  S * const head = *phead;
  if (head && head->next) {
    *phead = head->next;
    revS2( phead );
    head->next->next = head;
    head->next = NULL;
  }
}

But what's better than either of these is to reverse the list non-recursively. Neither of those functions is tail-recursive, so the compiler has to allocate new stack frames for each element in the list. Try to reverse a long enough list, and you'll blow your stack. Much better to just reverse the list using a while loop.

// reverse a list non-recursively
void revS3( S ** phead ){
  S * head = *phead;
  S * reversed = NULL;

  while (head) {
    S * curr = head;
    head = curr->next;
    curr->next = reversed;
    reversed = curr;
  }
  *phead = reversed;
}

Now we can test our results just by building lists out of the command line:

// just use the command line arguments as our list
int main(int argc, char** argv){

  S* list1 = mkS(argc - 1, argv + 1);
  S* list2 = mkS(argc - 1, argv + 1);
  S* list3 = mkS(argc - 1, argv + 1);

  showS( "given", list1 );

  showS( "revS1", revS1(list1) );

  revS2( &list2 );
  showS( "revS2", list2 );

  revS2( &list3 );
  showS( "revS3", list3 );

  return 0;
}

So let's compile:

% gcc -Wall linked_list.c -o linked_list 

And do some test runs

% ./linked_list 
given: ()
revS1: ()
revS2: ()
revS3: ()
% ./linked_list first second third 
given: ( first, second, third )
revS1: ( third, second, first )
revS2: ( third, second, first )
revS3: ( third, second, first )
% ./linked_list only
given: ( only )
revS1: ( only )
revS2: ( only )
revS3: ( only )