在C的递归函数中传递指针地址

Question

Im trying to understand the below code:

void recursiveReverse(struct node **head_ref)
{
    struct node *first;
    struct node *rest;

    if (*head_ref == NULL)
       return;   

    first = *head_ref;  
    rest  = first->next;
    if (rest == NULL)
       return;   
    recursiveReverse(&rest);
    first->next->next  = first;  
    first->next  = NULL;          
    *head_ref = rest;     
}

I noticed that the variable rest is having the same value for all the recursion call once the code reached beyond the recursiveReverse(&rest) . But first->next has different values. I was able to understand why first->next has different values by writing them on a stack and comparing it with each call. But i could not understand how rest is having the same value for all the calls instead of the (rest = first->next) from the stack. Please let me know if the question is not clear or if any details are needed. Thanks

Update: I observed that, arranging the parameters properly, if i call recursivereverse(rest) instead of revursivereverse(&rest), the rest value changes for every recursive call just like any other variable on the revursion stack. I could not understand what is the difference &rest is making in the call.

Answer 1

Consider the following input.

1 2 3 4.

First Recursion,

*Head_ref = 1;//value of head_Ref
 first =1; // first=*head_ref;
 rest=2;// rest=first->next;

Second recursion,

*Head_ref = 2;//value of head_Ref
 first =2; // first=*head_ref;
 rest=3;// rest=first->next;

Third Recursion.

*Head_ref = 3;//value of head_Ref
 first =3; // first=*head_ref;
 rest=4;// rest=first->next;

Fourth Recursion,

*Head_ref = 4;//value of head_Ref
 first =4; // first=*head_ref;
 rest=NULL;// rest=first->next;

Condition fails, It come to the third recursion , where it called.

Third Recursion,

    first=3;
    first->next->next=first// here it means the rest link.
    first->next=NULL;// it will make the pointer that is end.
    *head_ref=rest; // making the starting address in this recursion

Now the list comes like this, 4 -> 3. Now the value of rest is changed into 4.

Now it come to the second recursion,

Rest will pointing 4, but the first->next is pointing to 3.

first=2;
rest=4;
first->next->next=first// here it means the rest link.
first->next=NULL;// it will make the pointer that is end.
*head_ref=rest; // making the starting address in this recursion

So now the head_ref is pointing to 4. Then now the list will be 4 -> 3 -> 2.

It comes to the first recursion,

Here,

first=1,rest=4, But first -> next =2.
first->next->next=first// here it means the rest link.
first->next=NULL;// it will make the pointer that is end.
*head_ref=rest; // making the starting address in this recursion

At finally it change into

4 -> 3 -> 2 -> 1.

So now the list is reversed. Here main thing make the *head_ref into last position at end of the recursion.

Answer 2

consider a linked list 1->2->3->4 . As per the recursiveReverse() , at the iteration of recursive function call when (rest == NULL) is satisfied(node '4'), *head_ref = 4;Now after this, the call returns to previous iteration(node '3'). Here basically rest (= '4') variable of the current iteration of function recursion(node '3') is actually *head_ref of last iteration(last node '4') where *head_ref was calculated as 4. hence at the end of the function in recursion(node '3'), we are doing *head_ref = rest; ,ie. *head_ref = 4, since rest is received as 4 from function iteration node = '4'. now at next consecutive recursive returns from these functions, address of *head_ref is returned, which remains same through and hence the statement *head_ref = rest; gives the same values through out.