What is better way for merge sort? recursive function or non-recursive?

Question

I'm searching about merge sort and I found two kinds of functions.

First one is using recursion like this.

#include <stdio.h>

void merge(array, low, mid, high) {
    int temp[MAX];
    int i = low;
    int j = mid + 1;
    int k = low;

    while ((i <= mid) && (j <= high)) {
        if (array[i] <= array[j])
            temp[k++] = array[i++];
        else
            temp[k++] = array[j++];
    }/*End of while*/

    while (i <= mid)
        temp[k++] = array[i++];

    while (j <= high)
        temp[k++] = array[j++];

    for (i = low; i <= high; i++)
        array[i] = temp[i];

}/*End of merge()*/

void merge_sort(int low, int high) {
    int mid;
    if (low != high) {
        mid = (low + high) / 2;
        merge_sort(low, mid);
        merge_sort(mid + 1, high);
        merge(low, mid, high);
    }
}/*End of merge_sort*/

And then, I thought recursive function is not good for large arrays. This function causes a lot of recursive calls in this case. I think this is bad way of programming. (Actually I don't like recursion.)

So, I found other way, a merge sorting function without recursion:

#include <stdio.h>

#define MAX 30

int main() {
    int arr[MAX], temp[MAX], i, j, k, n, size, l1, h1, l2, h2;

    printf("Enter the number of elements : ");
    scanf("%d", &n);

    for (i = 0; i < n; i++) {
        printf("Enter element %d : ", i + 1);
        scanf("%d", &arr[i]);
    }

    printf("Unsorted list is : ");
    for (i = 0; i < n; i++)
        printf("%d ", arr[i]);

    /* l1 lower bound of first pair and so on */
    for (size = 1; size < n; size = size * 2) {
        l1 = 0;
        k = 0;  /* Index for temp array */
        while (l1 + size < n) {
            h1 = l1 + size - 1;
            l2 = h1 + 1;
            h2 = l2 + size - 1;
            /* h2 exceeds the limlt of arr */
            if (h2 >= n) 
                h2 = n - 1;

            /* Merge the two pairs with lower limits l1 and l2 */
            i = l1;
            j = l2;

            while (i <= h1 && j <= h2) {
                if (arr[i] <= arr[j])
                    temp[k++] = arr[i++];
                else
                    temp[k++] = arr[j++];
            }

            while (i <= h1)
                temp[k++] = arr[i++];
            while (j <= h2)
                temp[k++] = arr[j++];

            /** Merging completed **/
            /*Take the next two pairs for merging */
            l1 = h2 + 1; 
        }/*End of while*/

        /*any pair left */
        for (i = l1; k < n; i++) 
            temp[k++] = arr[i];

        for (i = 0; i < n; i++)
            arr[i] = temp[i];

        printf("\nSize=%d \nElements are : ", size);
        for (i = 0; i < n; i++)
            printf("%d ", arr[i]);

    }/*End of for loop */

    printf("Sorted list is :\n");
    for (i = 0; i < n; i++)
        printf("%d ", arr[i]);

    printf("\n");

    return 0;
}/*End of main()*/

I think this is better than using recursion. This function reduced recursion to a series of for and while loops! Of course, they have behave differently. I think a recursive function is not good for compiler. Am I right?

Answer 1

Assuming optimized implementations, iterative bottom up merge sort is somewhat faster than recursive top down merge sort, since it skips the recursive generation of indexes. For larger arrays, top down's additional overhead is relatively small, O(log(n)), compared to overall time of O(n log(n)), where in both cases, most of the time is spent doing a merge which can be identical for both bottom up and top down. Top down merge sort uses O(log(n)) stack space, while both use O(n) working space. However, almost all library implementations of stable sort are some variation of iterative bottom up merge sort, such as a hybrid of insertion sort and bottom up merge sort.

Link to an answer showing an optimized top down merge sort, using a pair of mutually recursive functions to control the direction of merge to avoid copying of data:

Mergesort implementation is slow

Link to an answer than includes a quick sort, 2 way bottom up merge sort, and 4 way bottom up merge sort:

Optimized merge sort faster than quicksort

Answer 2

You are somewhat right. Iterative bottom up merge sort is faster than recursive top down merge sort. Both methods are good for compiler ;) but recursive method takes more time to compile.

Answer 3

Your code for the recursive approach to merge sort has problems:

• the prototype for merge does not have the argument types.
• the array is missing from the arguments list of merge_sort
• passing high as the index of the last element is error prone and does not allow for empty arrays. You should instead pass the index to the first element beyond the end of the array, such that high - low is the number of elements in the slice to sort. This way the first call to merge_sort can take 0 and the array size.
• it is both wasteful and incorrect to allocate a full array int temp[MAX]; for each recursive call. Wasteful because the size might be much larger than needed, leading to potential stack overflow, and incorrect if high - low + 1 is larger than MAX leading to writing beyond the end of the array, causing undefined behavior.

This merge_sort function will call itself recursively at most log₂(high - low) times, each call allocating a temporary local array. The number of recursive calls is not the problem, only 30 for 1 billion records, but the local arrays are! If you try to sort a large array, there might not be enough space on the stack for a copy of this array, much less multiple copies, leading to undefined behavior, most likely a crash.

Note however that the iterative approach that you found has the same problem as it allocates temp[MAX] with automatic storage as well.

The solution is to allocate a temporary array from the heap at the top and pass it to the recursive function.

Here is an improved version:

#include <stdio.h>

static void merge(int *array, int *temp, int low, int mid, int high) {
    int i = low;
    int j = mid;
    int k = 0;

    while (i < mid && j < high) {
        if (array[i] <= array[j])
            temp[k++] = array[i++];
        else
            temp[k++] = array[j++];
    }

    while (i < mid)
        temp[k++] = array[i++];

    while (j < high)
        temp[k++] = array[j++];

    for (i = low, k = 0; i < high; i++, k++)
        array[i] = temp[k];
}

static void merge_sort_aux(int *array, int *temp, int low, int high) {
    if (high - low > 1) {
        int mid = (low + high) / 2;
        merge_sort_aux(array, temp, low, mid);
        merge_sort_aux(array, temp, mid, high);
        merge(array, temp, low, mid, high);
    }
}

int merge_sort(int *array, int size) {
    if (size > 1) {
        int *temp = malloc(size * sizeof(*temp));
        if (temp == NULL)
            return -1;

        merge_sort_aux(array, temp, 0, size);
        free(temp);
    }
    return 0;
}

// call from main as merge_sort(arr, MAX)