Recursion Part explanation - c++

Question

I am stuck with merge sort recursion part.
void divide(int arr[], int low, int high) {
int mid;
if(low < high) {
mid = (low + high)/2;
divide (arr, low, mid);
divide (arr, mid+1, high);
numbersSort (arr, low, mid, high);
}
}
Assume array size is four. first time it will be called by divide(arr,0,4) and then divide(arr,0,2), divide(arr,0,1), divide(arr,0,0) respectively.
But one word to say when it comes to divide(arr,0,0) it should be stop in low < high condition. Then how is it work for divide and numberSort() function?
I have an another query to ask, when does numberSort() work ?
if you can give my line by line by simulation of above code, I will be grateful to you . I am in serious panic about it.
Advance thanks.

Answer 1

Then how is it work for divide and numberSort() function?
Execution in a given function doesn't stop when you call another function, it just pauses until that function returns. So imagine you're currently executing divide(arr,0,1). low is still less than high, so you enter the condition and call divide(arr,0,0), which does whatever it needs to do (hint: try not to worry about what it does just now), and then you call divide(arr,1,1) which again does it's thing and returns. Next, you call numbersSort(arr,0,0,1), which recombines the two sections of the array, and the result is that the array is sorted from index 0 to index 1.
Good so far? Okay, well, next you just return. And it happens that the divide(arr,0,1) call we just talked about was invoked by a divide(arr,0,2) call, so when divide(arr,0,1) returns, execution of divide(arr,0,2) continues from the point just after the divide(arr,0,1). So the next thing to happen will be a divide(arr,2,2) call, right? 2 is not less than 2, so that just returns right away as well, and then you hit the numbersSort(arr,0,1,2), which combines the two sections of the array (i.e. 0 through 1, and 2 through 2) into a properly sorted array from 0 to 2. Now the array is sorted from index 0 through index 2.
But, of course, that divide(arr,0,2) was called in the context of a divide(arr,0,4) call, so when the divide(arr,0,2) returns the next thing that happens is divide(arr,3,4). Let's assume that that does the right thing and sorts the array from index 3 to index 4. And then you get to the numbersSort(arr,0,2,4), which combines the two parts of the array and returns to whatever function called divide(arr,0,4).
It can definitely be tough to get your head around recursion at first. Keep at it -- it'll click eventually. If you can step through the code for a small-ish example in a debugger, that might help you see what's going on. Also, working through the code on paper can help. Try not to get bogged down with understanding how it works at every level all at once, but instead look for what happens at a single level and trust that calls to any functions (even recursive calls) just do the right thing.

Answer 2

The example top down merge sort divide() function just keeps calling itself until the sub-array size is reduced to a size of 1, in which case a sub-array of size 1 can be considered sorted. Only then does any actual merging begin, starting just after divide(arr,0,0) and divide(arr,1,1) return after doing nothing. numbersSort() then merges arr[0] and arr[1], and it returns. The next merge occurs just after divide(arr,2,2) and divide(arr,3,3), merging arr[2] and arr[3]. Then after that return, arr[0 1] and arr[2 3] are merged, resulting in a sorted array of 4 integers. Note that all divide does is generate pairs of indexes (low, high), numbersSort() is where the actual merging of data is done.
In general, top down merge sort is a depth first, left first sort. The non-iterative bottom up merge sort skips all the recursion used to generate indexes and just starts off by merging by even and odd indexes, merging [0] with [1], [2] with [3], [4] with [5], ... . Then on the next pass it merges runs of size 2, [0 1] with [2 3], [4 5] with [6 7], ... and so on until the array is merged.
Passing a temp array of the same size as the array to be sorted can be used to eliminate have to create, copy, and delete working arrays during a merge sort.
Example showing top down merge sort order of operation:
7 4 2 5 3 0 6 1
7 4 2 5|3 0 6 1
7 4|2 5
7|4
4 7
2|5
2 5
2 4 5 7
3 0|6 1
3|0
0 3
6|1
1 6
0 1 3 6
0 1 2 3 4 5 6 7
Example showing bottom up merge sort order of operation:
7 4 2 5 3 0 6 1
7|4|2|5|3|0|6|1 run size = 0
4 7|2 5|0 3|1 6 run size = 1
2 4 5 7|0 1 3 6 run size = 4
0 1 2 3 4 5 6 7 done