排序算法（2）归并排序

时间复杂度：$O(NlogN)$

非原地排序

没办法啊，在合并的那个步骤是要申请额外的空间的。

空间复杂度$O(N)$

归并的步骤

其实归并是所有的排序里最好记的，效率最好的算法了，比起快排；堆排序。归并，你记住步骤就不难了。
其实称之为“归并”并不准确。更加准确应该是“分开”-“归并”。
首先我们把数组一分为二，然后再分，然后再分。
然后再去把数组进行归并。
说的简单点就是“分”-“总”的过程。

优势是什么？

1）稳定的$O(NlogN)$
其实时间复杂度为$O(NlogN)$的排序不少啊，归并的存在的意义是啥？它可是稳定的$O(NlogN)$ 哦，我们晓得，快速排序号称$O(NlogN)$，但是实际上很难真正达到$O(NlogN)$，因为选拆分点会很随机，起码在单轴快排的时候是这样的，如果每次选的都是什么最小值最大值就很尬了。
但是我们的归并，这个是稳定的。
2）实现简单：
这个很重要，如果你让我手写一个堆排序，那么基本我写不出来，原理倒是可以解释，不过就是马上实现，有点难；但是归并，那就，哈哈哈，只要知道原理，实现简单。

劣势是什么？

1）要额外空间
这个没办法，就要额外的空间来存放临时数组
2）要不断的搬移操作
还要从额外数组把数据搬回来的操作。
SHOW THE CODE

public void mergeSort(int[] arr) {
    int len = arr.length;
    mergeSort(arr, 0, len - 1);

}

public void mergeSort(int[] arr, int beginIndex, int endIndex) {
    if (beginIndex >= endIndex) {
        return;
    }
    int midIndex = beginIndex + ((endIndex - beginIndex) >> 1);

    mergeSort(arr, beginIndex, midIndex);
    mergeSort(arr, midIndex + 1, endIndex);
    mergeCore(arr, beginIndex, midIndex, endIndex);
}


private void mergeCore(int[] arr, int startIndex, int midIndex, int endIndex){
    int[] temp = new int[endIndex - startIndex + 1];
    int tempIndex = 0;
    int leftIndex = startIndex;
    int rightIndex = midIndex + 1;
    while (leftIndex <= midIndex && rightIndex <= endIndex) {
        if (arr[leftIndex] <  arr[rightIndex]) {
            temp[tempIndex] = arr[leftIndex];
            leftIndex++;
        } else {
            temp[tempIndex] = arr[rightIndex];
            rightIndex++;
        }
        tempIndex++;
    }
    while (leftIndex <= midIndex) {
        temp[tempIndex] = arr[leftIndex];
        leftIndex++;
        tempIndex++;
    }

    while (rightIndex <= endIndex) {
        temp[tempIndex] = arr[rightIndex];
        rightIndex++;
        tempIndex++;
    }

    for (int i = 0, len = temp.length; i < len; ++i) {
        arr[startIndex+i] = temp[i];
    }
}