### **归并排序**
> 如果阅读时，发现错误，或者动画不可以显示的问题可以添加我微信好友 **[tan45du_one](https://raw.githubusercontent.com/tan45du/tan45du.github.io/master/个人微信.15egrcgqd94w.jpg)** ，备注 github + 题目 + 问题 向我反馈
>
> 感谢支持，该仓库会一直维护，希望对各位有一丢丢帮助。
>
> 另外希望手机阅读的同学可以来我的 [**公众号：袁厨的算法小屋**](https://raw.githubusercontent.com/tan45du/test/master/微信图片_20210320152235.2pthdebvh1c0.png) 两个平台同步，想要和题友一起刷题，互相监督的同学，可以在我的小屋点击[**刷题小队**](https://raw.githubusercontent.com/tan45du/test/master/微信图片_20210320152235.2pthdebvh1c0.png)进入。
归并排序是必须要掌握的排序算法，也算是面试高频考点，下面我们就一起来扒一扒归并排序吧，原理很简单，大家一下就能搞懂。
袁记菜馆内
第 23 届食神争霸赛开赛啦！
袁厨想在自己排名前 4 的分店中，挑选一个最优秀的厨师来参加食神争霸赛，选拔规则如下。
第一场 PK：每个分店选出两名厨师，首先进行店内 PK,选出店内里的胜者
第二场 PK: 然后店内的优胜者代表分店挑战其他某一分店的胜者（半决赛）
第三场 PK：最后剩下的两名胜者进行 PK,选出最后的胜者。
示意图如下
上面的例子大家应该不会陌生吧，其实我们归并排序和食神选拔赛的流程是有些相似的，下面我们一起来看一下吧
归并这个词语的含义就是合并，并入的意思，而在我们的数据结构中的定义是将**两个或两个以上的有序表和成一个新的有序表**。而我们这里说的归并排序就是使用归并的思想实现的排序方法。
归并排序使用的就是分治思想。顾名思义就是分而治之，将一个大问题分解成若干个小的子问题来解决。小的子问题解决了，大问题也就解决了。分治后面会专门写一篇文章进行描述滴，这里先简单提一下。
下面我们通过一个图片来描述一下归并排序的数据变换情况，见下图。
我们简单了解了归并排序的思想，从上面的描述中，我们可以知道算法的归并过程是比较难实现的，这也是这个算法的重点，看完我们这个视频就能懂个大概啦。
视频中归并步骤大家有没有看懂呀，没看懂也不用着急，下面我们一起来拆解一下，归并共有三步走。
第一步：创建一个额外大集合用于存储归并结果，长度则为那两个小集合的和，从视频中也可以看的出
第二步：我们从左自右比较两个指针指向的值，将较小的那个存入大集合中，存入之后指针移动，并继续比较，直到某一小集合的元素全部都存到大集合中。见下图
第三步：当某一小集合元素全部放入大集合中，则需将另一小集合中剩余的所有元素存到大集合中，见下图
好啦，看完视频和图解是不是能够写出个大概啦，了解了算法原理之后代码写起来就很简单啦，
下面我们看代码吧。
Java Code:
```java
class Solution {
public int[] sortArray(int[] nums) {
mergeSort(nums,0,nums.length-1);
return nums;
}
public void mergeSort(int[] arr, int left, int right) {
if (left < right) {
int mid = left + ((right - left) >> 1);
mergeSort(arr,left,mid);
mergeSort(arr,mid+1,right);
merge(arr,left,mid,right);
}
}
//归并
public void merge(int[] arr,int left, int mid, int right) {
//第一步，定义一个新的临时数组
int[] temparr = new int[right -left + 1];
int temp1 = left, temp2 = mid + 1;
int index = 0;
//对应第二步，比较每个指针指向的值，小的存入大集合
while (temp1 <= mid && temp2 <= right) {
if (arr[temp1] <= arr[temp2]) {
temparr[index++] = arr[temp1++];
} else {
temparr[index++] = arr[temp2++];
}
}
//对应第三步，将某一小集合的剩余元素存到大集合中
if (temp1 <= mid) System.arraycopy(arr, temp1, temparr, index, mid - temp1 + 1);
if (temp2 <= right) System.arraycopy(arr, temp2, temparr, index, right -temp2 + 1); //将大集合的元素复制回原数组
System.arraycopy(temparr,0,arr,0+left,right-left+1);
}
}
```
Python Code:
```python
from typing import List
class Solution:
def sortArray(self, nums: List[int])->List[int]:
self.mergeSort(nums, 0, len(nums) - 1)
return nums
def mergeSort(self, arr: List[int], left: int, right: int):
if left < right:
mid = left + ((right - left) >> 1)
self.mergeSort(arr, left, mid)
self.mergeSort(arr, mid + 1, right)
self.merge(arr, left, mid, right)
# 归并
def merge(self, arr: List[int], left: int, mid: int, right: int):
# 第一步，定义一个新的临时数组
temparr = [0] * (right - left + 1)
temp1 = left
temp2 = mid + 1
index = 0
# 对应第二步，比较每个指针指向的值，小的存入大集合
while temp1 <= mid and temp2 <= right:
if arr[temp1] <= arr[temp2]:
temparr[index] = arr[temp1]
index += 1
temp1 += 1
else:
temparr[index] = arr[temp2]
index += 1
temp2 += 1
# 对应第三步，将某一集合的剩余元素存到大集合中
if temp1 <= mid:
temparr[index: index + mid - temp1 + 1] = arr[temp1: temp1 + mid - temp1 + 1]
if temp2 <= right:
temparr[index: index + right - temp2 + 1] = arr[temp2: temp2 + right - temp2 + 1]
# 将大集合的元素复制回原数组
arr[left: left + right- left + 1] = temparr[0: right - left + 1]
```
**归并排序时间复杂度分析**
我们一趟归并，需要将两个小集合的长度放到大集合中，则需要将待排序序列中的所有记录扫描一遍所以时间复杂度为 O(n)。归并排序把集合一层一层的折半分组，则由完全二叉树的深度可知，整个排序过程需要进行 logn（向上取整）次,则总的时间复杂度为 O(nlogn)。另外归并排序的执行效率与要排序的原始数组的有序程度无关，所以在最好，最坏，平均情况下时间复杂度均为 O(nlogn) 。虽然归并排序时间复杂度很稳定，但是他的应用范围却不如快速排序广泛，这是因为归并排序不是原地排序算法，空间复杂度不为 O(1)，那么他的空间复杂度为多少呢？
**归并排序的空间复杂度分析**
归并排序所创建的临时结合都会在方法结束时释放，单次归并排序的最大空间是 n ,所以归并排序的空间复杂度为 O(n).
**归并排序的稳定性分析**
归并排序的稳定性，要看我们的 merge 函数，我们代码中设置了 arr[temp1] <= arr[temp2] ，当两个元素相同时，先放入 arr[temp1] 的值到大集合中，所以两个相同元素的相对位置没有发生改变，所以归并排序是稳定的排序算法。
| 算法名称 | 最好时间复杂度 | 最坏时间复杂度 | 平均时间复杂度 | 空间复杂度 | 是否稳定 |
| -------- | -------------- | -------------- | -------------- | ---------- | -------- |
| 归并排序 | O(nlogn) | O(nlogn) | O(nlogn) | O(n) | 稳定 |
等等还没完嘞，不要走。
归并排序的递归实现是比较常见的，也是比较容易理解的，下面我们一起来扒一下归并排序的迭代写法。看看他是怎么实现的。
我们通过一个视频来了解下迭代方法的思想，
是不是通过视频了解个大概啦，下面我们来对视频进行解析。
迭代实现的归并排序是将小集合合成大集合，小集合大小为 1,2,4,8,.....。依次迭代，见下图
比如此时小集合大小为 1 。两个小集合分别为 [3],[1]。然后我们根据合并规则，见第一个视频，将[3],[1]合并到临时数组中，则小的先进，则实现了排序，然后再将临时数组的元素复制到原来数组中。则实现了一次合并。
下面则继续合并[4],[6]。具体步骤一致。所有的小集合合并完成后，则小集合的大小变为 2，继续执行刚才步骤，见下图。
此时子集合的大小为 2 ，则为 [2,5],[1,3] 继续按照上面的规则合并到临时数组中完成排序。 这就是迭代法的具体执行过程，
下面我们直接看代码吧。
注：递归法和迭代法的 merge 函数代码一样。
Java Code:
```java
class Solution {
public int[] sortArray (int[] nums) {
//代表子集合大小，1，2，4，8，16.....
int k = 1;
int len = nums.length;
while (k < len) {
mergePass(nums,k,len);
k *= 2;
}
return nums;
}
public void mergePass (int[] array, int k, int len) {
int i;
for (i = 0; i < len-2*k; i += 2*k) {
//归并
merge(array,i,i+k-1,i+2*k-1);
}
//归并最后两个序列
if (i + k < len) {
merge(array,i,i+k-1,len-1);
}
}
public void merge (int[] arr,int left, int mid, int right) {
//第一步，定义一个新的临时数组
int[] temparr = new int[right - left + 1];
int temp1 = left, temp2 = mid + 1;
int index = 0;
//对应第二步，比较每个指针指向的值，小的存入大集合
while (temp1 <= mid && temp2 <= right) {
if (arr[temp1] <= arr[temp2]) {
temparr[index++] = arr[temp1++];
} else {
temparr[index++] = arr[temp2++];
}
}
//对应第三步，将某一小集合的剩余元素存到大集合中
if (temp1 <= mid) System.arraycopy(arr, temp1, temparr, index, mid - temp1 + 1);
if (temp2 <= right) System.arraycopy(arr, temp2, temparr, index, right -temp2 + 1);
//将大集合的元素复制回原数组
System.arraycopy(temparr,0,arr,0+left,right-left+1);
}
}
```
Python Code:
```python
from typing import List
class Solution:
def sortArray(self, nums: List[int])->List[int]:
# 代表子集合大小，1，2，4，8，16.....
k = 1
leng = len(nums)
while k < leng:
self.mergePass(nums, k, leng)
k *= 2
print(nums)
return nums
def mergePass(self, array: List[int], k: int, leng: int):
i = 0
while i < leng - 2 * k:
# 归并
self.merge(array, i, i + k - 1, i + 2 * k - 1)
i += 2 * k
# 归并最后两个序列
if i + k < leng:
self.merge(array, i, i + k - 1, leng - 1)
# 归并
def merge(self, arr: List[int], left: int, mid: int, right: int):
# 第一步，定义一个新的临时数组
temparr = [0] * (right - left + 1)
temp1 = left
temp2 = mid + 1
index = 0
# 对应第二步，比较每个指针指向的值，小的存入大集合
while temp1 <= mid and temp2 <= right:
if arr[temp1] <= arr[temp2]:
temparr[index] = arr[temp1]
index += 1
temp1 += 1
else:
temparr[index] = arr[temp2]
index += 1
temp2 += 1
# 对应第三步，将某一集合的剩余元素存到大集合中
if temp1 <= mid:
temparr[index: index + mid - temp1 + 1] = arr[temp1: temp1 + mid - temp1 + 1]
if temp2 <= right:
temparr[index: index + right - temp2 + 1] = arr[temp2: temp2 + right - temp2 + 1]
# 将大集合的元素复制回原数组
arr[left: left + right- left + 1] = temparr[0: right - left + 1]
```