使用C中的递归来反向链接列表

Question

I was trying the reversal of a linked list using recursion. I viewed the sample program in geeksforgeeks website. They had a good explanation . But I could not understand what the *headref will hold on every stack unwinding. Doesnt it hold the next address during every stack unwinding, if its that way then how does the rest value is same during all the stack unwinding calls. The first value gets changed during the stack unwinding and so is the rest value. Why doesnt rest value is not changed when the first value is changed for every stack unwinding. Please help to understand.

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

    /* empty list */
    if (*head_ref == NULL)
       return;  

    /* suppose first = {1, 2, 3}, rest = {2, 3} */
    first = *head_ref; 
    rest  = first->next;

    /* List has only one node */
    if (rest == NULL)
       return;  

    /* reverse the rest list and put the first element at the end */
    recursiveReverse(&rest);
    first->next->next  = first; 

    /* tricky step -- see the diagram */
    first->next  = NULL;         

    /* fix the head pointer */
    *head_ref = rest;             
}

Answer 1

Once the 'rest list' got reversed in the recursive step, its first item, pointed at by rest , became its last item, so the previous 'first' gets appended after that. Then it is the last item, so its next member becomes NULL . Finally we return the new head through the call parameter.

Answer 2

The head is changed in every recursive call.

Each recursive call takes the sublist [k,n] , where k is the previously parsed elements.

The first entry is [0,n] , which in the code above is [first,rest] .

Initially links are from first to rest. Before each recursive call rest gets linked to first having a temporary loop inside the list (first points to rest, rest points to first).

Then , after the recursive call returns, the loop is killed by removing the first to rest link and putting first to be rest's next . (basically keeping only the inverse order).

As any single linked list, the last element needs to have no childern, and right now first is the last element, so first->next becomes null.

The new head of the list is the last element, which in this case will be rest , which gets passed on from the deepest recursion upwards.

This algorithm is so much faster and easier to implement with an iterative approach.

Answer 3

Problem of such algorithm is memory consumption required by recursive calls.

You have one parameter pointer and two var pointer, each call that goes on top of the memory stack. But it is the reason it works and the var is not changed. It does not reference the same memory area.

You can note that an iterative approch is faster and easier in fact.

void iterativeReverse(struct node** head_ref) {
    struct node *prev=NULL, *next;
    while (*head_ref) {
       next=*head_ref->next;
       *head_ref->next=prev;
       prev=*head_ref;
       *head_ref=next;
    }
    *head_ref=prev;
}