I don't fully understand when these recursive calls return - recursion

Question

I understand simple recursion code but sometimes when it gets a bit complicated. I get lost and can't really follow the code.
For example of the follow code(an anonymous wrote it):
void reversetree(struct node* head)
{
//first check for the exception whether does it even exit or not
if(head==NULL)
return ;
reversetree(head->left); //reverse call for left child
reversetree(head->right); //same reverse call for right child
//now next these steps will swap the children
struct node* temp=head->left;
head->left=head->right;
head->right=head->left;
//now exit the function and you are done :)
}
6
/ \
3 4
/ \ / \
1 2 8 9
Lets say if the binary tree looks like this,can someone do a step by step logic for me please? For my understanding, it first checks to see if the root exists, if it does then it call the function again of the left child until there is no more left child? so when the the code that swaps it ever get called? and when does it start calling the function with the right child? Sorry I am not too bright with recursions.

Answer 1

Usually when dealing with recursion people tend to tell you to do it with pen and paper. Its a great exercise, but I find it easier to do it these ways:
First way to look at it
There is no difference between using a recursive function and a different function that performs the same job. They both do their job and return so that your code resumes on the next line.
Imagine you have a working function, reversetree_external that reverses a whole tree so that you could write your function this way without recursion:
void reversetree(struct node* head)
{
if(head==NULL)
return ;
// switch left and right
struct node* temp=head->left;
head->left=head->right;
head->right=temp; // There was an error here
// Reverse subtrees
reversetree_external(head->left);
reversetree_external(head->right);
}
So everything you need to convince yourself of is that given an argument like:
6
/ \
3 4
/ \ / \
1 2 8 9
Turns into the following before reversetree_external reverses the two subtrees:
6
/ \
4 3
/ \ / \
8 9 1 2
If you only pass one of right and left it would turn that level before using reversetree_external to not do anything.
If you pass it a leaf node, eg. 8 the result is the same 8 (with the null pointers swapped) and reversetree_external won't do anything since it will be given NULL both times.
In fact You can see that reversetree can do the same thing as reversetree_external so instead of relying on it you can just use reversetree itself.
Second way to look at it
Now, it's good to look at this in two ways so do it in reverse, eg. start with NULL.. eg. the left node of 8, then a leaf, then a tree that uses the leaves and then a full tree using the subtrees we have calculated in advance.
input result
NULL NULL
8 8
9 9
1 1
2 2
4 4
/ \ / \
8 9 9 8
3 3
/ \ / \
1 2 2 1
6 6
/ \ / \
3 4 4 3
/ \ / \ / \ / \
1 2 8 9 9 8 2 1
So in place of doing the recursion in my mind I just use the previous result in the results which you know the same function would do. eg. I switch the 3 and 4 as the procedure would use and the two recursions is just the same transformation as the subtree done before.
The first way is just how to read recursive code, the second way is perhaps the easiest and how you can make your own recursive functions with ease. You start with the base case(es) and test them, then add a default case how to do a slightly more complex problem into a smaller similar problem that eventually ends up being a base case.

Answer 2

If the root does not exist, the function quits because it has no children.
Yes, the processor will then follow the chain of left children until it runs out, then the left children of the last node's right child ...
For the tree shown, here's what will happen:
Reverse node 6:
Reverse node 3:
Reverse node 1:
Reverse NULL
Reverse NULL
Swap 1's links to NULL and NULL
Reverse node 2:
Reverse NULL
Reverse NULL
Swap 2's links to NULL and NULL
Swap 3's links to 1 and 2
Reverse node 4:
Reverse node 8:
Reverse NULL
Reverse NULL
Swap 8's links to NULL and NULL
Reverse node 9:
Reverse NULL
Reverse NULL
Swap 9's links to NULL and NULL
Swap 4's links to 8 and 9
Swap 6's links to 3 and 4
It would run a bit faster with a test for NULL before each call.
The swap step could go before the recursive calls, without affecting the speed or result.