递归链表反向器

Question

Created a linked list class for a java project and needed a method to reverse the list so my friend and I eventually came up with the following recursive method and it's helper method:

(just for clarification, first is the instance variable of the first node in the list)

public void reverse()
{
    first = reverse(first);
}

public Node reverse(Node in) 
{
    if (in == null || in.next == null) 
    {
         return in;
    }

         Node next = in.next;
         in.next = null;
         Node rest = reverse(next);
         next.next = in;
         return rest;
}

When the nodes contain integers and we input 1, 2, and 3 at the beginning of the list (they become 3, 2, 1 when added as the first node) and then try to reverse the 3, 2, 1 to become 1, 2, 3 the function works as planned.

My issue here is that I really am having trouble comprehending what is happening here.

For instance, when I trace the function (for 3, 2, 1) it appears that:

next = in.next (which is 2, 1 ) gets passed down again until it is just (1) and then that gets passed back up into rest . But after the recursion takes place, nothing is actually happening to rest . It's happening to next.next and I cannot make out how next.next is affecting rest in any way.

I can't seem to locate the points in which rest goes from being (1) to (1,2) to (1,2,3) during the bubbling back up.

If anyone could help explain more in depth how this function is modifying rest that would be great. I have traced this function almost 20 or so times now trying to understand and something is taking place that I just can't seem to see.

I even took it to my teacher and he gave me some BS response equivalent to "If it works, then it works, it's recursion, don't try to understand it." -- What kind of advice is that??

Thanks

Answer 1

Try drawing a list with 2 nodes in it. This is the simplest example.

first --> [A] -> [B] -> null

We invoke reverse(first) , and since A is not-null, we result in the following assignments:

in = A
next = B

We break the link between A and B at this step:

in.next = null;

So, we have:

first --> [A]  [B] -> null

Now we want the rest, which gets assigned to a recursive call of this function, with B instead. We repeat the steps now with B, but since B.next is null, we're only left with B.

So, we get B back as the result of rest . We now assign next.next to in , which means that B.next is now A .

[B] -> [A] -> null
        ^
      first

We return rest back to whomever called it, which in this case, results in the assignment to first .

first --> [B] -> [A] -> null

...and now, the list is reversed.

This is the general breakdown of it; take a look at it with three nodes and you'll see a bit more behavior. Remember: each recursive call creates new variables for in and next , and the ones that existed previously are set aside until we return from this particular method.