Java's seven major sorting methods: merge sort (including non-recursive methods)

(1) Basic idea

Merge sort is an effective sorting algorithm based on merge operations. This algorithm is a very typical application of the divide-and-conquer method. Merge the already ordered subsequences to obtain a completely ordered sequence; that is, first make each subsequence orderly, and then make the subsequence segments orderly. If two ordered lists are merged into one ordered list, it is called a two-way merge.

Two steps:

1. When the ordered list has only one element, the decomposition ends.

2. Combine, merge the two ordered lists.

(2) Code implementation

public static void mergeSort(int[] array) {
        mergeSortFunc(array,0,array.length-1);
    }
    private static void mergeSortFunc(int[] array,int left,int right) {
        if (left >= right) {
            return;
        }
        int mid = (left+right)/2;
        mergeSortFunc(array,left,mid); //先走左边
        mergeSortFunc(array,mid+1,right); //再走右边
        merge(array, left, right,mid); // 合并

    }
    private static void merge(int[] array,int start,int end,int mid) {
        int s1 = start;
        int s2 = mid+1;
        int[] tmp = new int[end];
        int k = 0; // 表示tmp数组的下标
        while (s1 <= mid && s2 <= end) {
            if (array[s1] <= array[s2]) {
                tmp[k++] = array[s1++];
            } else {
                tmp[k++] = array[s2++];
            }
        }
        while (s1 <= mid) {
            tmp[k++] = array[s1++];
        }
        while (s2 <= mid) {
            tmp[k++] = array[s2++];
        }
        for (int i = 0; i < tmp.length; i++) {
            array[i+start] = tmp[i]; //将tmp数组的元素copy到array数组中
        }
    }

Non-recursive implementation of merge sort

 public static void mergeSort2(int[] array) {
        int gap = 1;
        while (gap < array.length) {
            for (int i = 0; i < array.length; i += gap*2) {
                int left = i;
                int mid = left+gap - 1;
                if (mid >= array.length) {
                    mid = array.length-1;
                }
                int right = mid+gap;
                if (right >= array.length) {
                    right = array.length-1;
                }
                merge(array,left,right,mid);
            }
            gap *= 2;
        }
    }

(3) Feature summary

1. The disadvantage of merging is that it requires O(N) space complexity. The thinking of merging and sorting is more about solving the external sorting problem on the disk.

2. Time complexity: O(N*logN) Space complexity: O(N)

3. Stability: Stable