排序算法-归并排序

今天的北京格外的闷热，吃过晚饭打开电脑进行今天的第五个排序算法的学习，炎炎夏日，大家要注意防暑哦，下面开始学习了，一天进步一点。

原创不易，如果转载请注明链接：
https://blog.youkuaiyun.com/qq_38305457/article/details/96893538

我不能保证写的每个地方都是对的，但是至少能保证不复制，不黏贴，保证每一句话，每一行代码都经过了认真的推敲，仔细的斟酌。每一篇文章的背后，希望都能看到自己对于技术，对于生活的态度。
我相信乔布斯说的，只有那些疯狂到认为自己可以改变世界的人才能真正的改变世界。
面对压力，我可以挑灯夜战，不眠不休；面对困难，我愿意迎难而上，永不退缩。 其实我想说的是：我只是一个程序员，这就是我现在纯粹人生的全部。

归并排序是建立在归并操作上的一种有效的排序算法，1945年由约翰·冯·诺伊曼首次提出。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用，且各层分治递归可以同时进行。

1、思路分析

归并排序算法是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。

2、算法思想

归并排序可通过两种方式实现：
•自上而下的递归
•自下而上的迭代

一、递归法（假设序列共有n个元素）：

①. 将序列每相邻两个数字进行归并操作，形成 floor(n/2)个序列，排序后每个序列包含两个元素；
②. 将上述序列再次归并，形成 floor(n/4)个序列，每个序列包含四个元素；
③. 重复步骤②，直到所有元素排序完毕。
二、迭代法

①. 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列
②. 设定两个指针，最初位置分别为两个已经排序序列的起始位置
③. 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置
④. 重复步骤③直到某一指针到达序列尾
⑤. 将另一序列剩下的所有元素直接复制到合并序列尾

3、示例代码

归并排序其实要做两件事：
•分解：将序列每次折半拆分
•合并：将划分后的序列段两两排序合并

因此，归并排序实际上就是两个操作，拆分+合并

如何合并？

L[first…mid]为第一段，L[mid+1…last]为第二段，并且两端已经有序，现在我们要将两端合成达到L[first…last]并且也有序。

首先依次从第一段与第二段中取出元素比较，将较小的元素赋值给temp[]
重复执行上一步，当某一段赋值结束，则将另一段剩下的元素赋值给temp[]
此时将temp[]中的元素复制给L[]，则得到的L[first…last]有序

如何分解？
在这里，我们采用递归的方法，首先将待排序列分成A,B两组；然后重复对A、B序列
分组；直到分组后组内只有一个元素，此时我们认为组内所有元素有序，则分组结束。

这里我写了递归算法如下：

**
 * 归并排序（递归）
 *
 * ①. 将序列每相邻两个数字进行归并操作，形成 floor(n/2)个序列，排序后每个序列包含两个元素；
 * ②. 将上述序列再次归并，形成 floor(n/4)个序列，每个序列包含四个元素；
 * ③. 重复步骤②，直到所有元素排序完毕。
 * @param arr    待排序数组
 */
public static int[] mergingSort(int[] arr){
 if(arr.length <= 1) return arr;

 int num = arr.length >> 1;
 int[] leftArr = Arrays.copyOfRange(arr, 0, num);
 int[] rightArr = Arrays.copyOfRange(arr, num, arr.length);
 System.out.println("split two array: " + Arrays.toString(leftArr) + " And " + Arrays.toString(rightArr));
 return mergeTwoArray(mergingSort(leftArr), mergingSort(rightArr));      //不断拆分为最小单元，再排序合并
}

private static int[] mergeTwoArray(int[] arr1, int[] arr2){
 int i = 0, j = 0, k = 0;
 int[] result = new int[arr1.length + arr2.length];  //申请额外的空间存储合并之后的数组
 while(i < arr1.length && j < arr2.length){      //选取两个序列中的较小值放入新数组
 if(arr1[i] <= arr2[j]){
 result[k++] = arr1[i++];
 }else{
 result[k++] = arr2[j++];
 }
 }
 while(i < arr1.length){     //序列1中多余的元素移入新数组
 result[k++] = arr1[i++];
 }
 while(j < arr2.length){     //序列2中多余的元素移入新数组
 result[k++] = arr2[j++];
 }
 System.out.println("Merging: " + Arrays.toString(result));
 return result;
}

由上, 长度为n的数组, 最终会调用mergeSort函数2n-1次。通过自上而下的递归实现的归并排序, 将存在堆栈溢出的风险。

以下是归并排序算法复杂度:

从效率上看，归并排序可算是排序算法中的”佼佼者”. 假设数组长度为n，那么拆分数组共需logn，, 又每步都是一个普通的合并子数组的过程， 时间复杂度为O(n)， 故其综合时间复杂度为O(nlogn)。另一方面， 归并排序多次递归过程中拆分的子数组需要保存在内存空间， 其空间复杂度为O(n)。