数据结构与算法-归并排序

执行流程： 1：不断将当前数列平均分成2个子序列，直到序列中只有一个元素为止。 2：不断将2个子序列合并成一个子序列，直到最终只剩下1个有序序列

/**
 * 归并排序
 *
 * @author jun.zhang6
 * @date 2020/9/27
 */
public class MergeSort {
    public static void main(String[] args) {
        int[] array = {8, 7, 6, 5, 4, 3, 2, 1};
        MergeSort mergeSort = new MergeSort(array);
        mergeSort.sort(0, array.length);
        Arrays.stream(array).forEach(System.out::println);
    }

    private int[] array;

    private int[] leftArray;

    public MergeSort(int[] array) {
        this.array = array;
        this.leftArray = new int[array.length >> 1];
    }

    public void sort(int begin, int end) {
        if (end - begin < 2) {
            return;
        }
        int mid = (begin + end) >> 1;
        sort(begin, mid);
        sort(mid, end);
        merge(begin, mid, end);
    }

    private void merge(int begin, int mid, int end) {
        //左边数组基于leftArray
        int li = 0, le = mid - begin;
        //右边的数组基于array
        int ri = mid, re = end;
        //array的索引
        int ai = begin;
        //拷贝左边的数组到leftArray
        for (int i = li; i < le; i++) {
            leftArray[i] = array[begin + i];
        }
        while (li < le) {
            if (ri < re && array[ri] < leftArray[li]) {
                array[ai++] = array[ri++];
            } else {
                array[ai++] = leftArray[li++];
            }
        }
    }
}

merge-左边先结束

merge-右边先结束

总结： 归并排序平均时间复杂度为O(nlogn)，空间复杂度为O(n)。