- 基本思想
- 步骤
- 实例分析
- 伪代码
- 代码实现JAVA
- 性能分析
- 应用：常见面试题目
【基本思想】
利用归并的思想实现的排序方法，该算法采用经典的分治（divide-and-conquer）策略
Divide and Conquer分治思想
将原问题分成若干规模更小，但结构相似的小问题。递归解决子问题，再把子问题的解组合为原问题的解。
【步骤】
将待排序的数分成两半后排好序，然后再将两个排好序的序列合并成一个有序序列
【实例分析】
以数组6 5 3 1 8 7 2 4为例。首先递归的将数组一分为2，并对子数组排序
[6, 5, 3, 1] [8, 7, 2, 4]
[6, 5] [3, 1] [8, 7] [2, 4]
[6], [5] [4], [3] [7], [8] [2], [4]
然后向上回溯，将两个数组合并成有序数组
[6], [5] [4], [3] [7], [8] [2], [4]
[5, 6] [3, 4] [7, 8] [2, 4]
[3, 4, 5, 6] [2, 4, 7, 8]
[1, 2, 3, 4, 5, 6, 7, 8]
动图如下所示
(维基百科)
【伪代码】
MERGE_SORT(A, p, r)
if p < r
q = (p + r) / 2
MERGE_SORT(A, p, q)
MERGE_SORT(A, q + 1, r)
MERGE(A, p, q, r)
MERGE(A, p, q, r)
len = r-p+1
tmp[len], i = p, j = 1+1
i(p==>q)&&j(q+1==>r) min==>tmp[]
tmp==>arr
【JAVA代码实现】
public class mergeSort
{
public static void main(String[] args)
{
int[] arr = {6,5,3,1,8,7,2,4};
merge_sort(arr, 0, arr.length-1);
}
public static void merge_sort(int[] arr, int p, int r) {
if(p < r) {
int q = (p+r)/2; //中间值
merge_sort(arr, p, q); //递归调用左半边，分成两组
merge_sort(arr, q+1, r); //递归调用右半边，分成两组
merge(arr, p, q, r); //分完后排序
}
}
public static void merge(int[] arr, int p, int q, int r) {
int len = r-p+1; //长度
int[] tmp = new int[len]; //临时数组
int i = p, j = q+1; //两段[p, q][q+1,r]
int k = 0;
while(i <= q && j <= r) {//比较最小的存入tmp数组
if(arr[i] < arr[j]) {
tmp[k++] = arr[i++];
}else {
tmp[k++] = arr[j++];
}
}
//i,j其中一个已经全部放入临时数组中
while(i <= q) {
tmp[k++] = arr[i++];
}
while(j <= r) {
tmp[k++] = arr[j++];
}
//tmp赋给原数组
for(int m = 0; m < len;m++) {
arr[m+p] = tmp[m];
}
}
运行结果
5 6 3 1 8 7 2 4
5 6 1 3 8 7 2 4
1 3 5 6 8 7 2 4
1 3 5 6 7 8 2 4
1 3 5 6 7 8 2 4
1 3 5 6 2 4 7 8
1 2 3 4 5 6 7 8
1 2 3 4 5 6 7 8
【性能分析】
快速排序的时间性能取决于快速排序递归的深度，可以用递归树来描述递归算法的执行情况。
1. 最优
时间复杂度为O(nlogn)
假设处理的数据规模大小为 N，运行时间设为：T(N)
① 当把 N 分为两半时，那么处理大小为 N/2 子数组花费时间为：T(N/2)
② 合并花费时间与数据规模成正比:N
所以处理规模大小为N的数据所需要花费两个大小为 N/2 的子数组加上合并花费的时间
即：T(N) = 2T(N/2) + N
T(1) = 1
2. 最坏 && 平均
因为不管元素在什么情况下都要做这些步骤，所以花销的时间是不变的，所以该算法的最优时间复杂度和最差时间复杂度及平均时间复杂度都是一样的为：O( nlogn )
4. 空间复杂度
空间复杂度就比较大，因为它需要每次申请一个数组来存归并的数字
归并的空间复杂度就是那个临时的数组和递归时压入栈的数据占用的空间：n + logn；所以空间复杂度为: O(n)
5. 稳定性
是通过比较移动的，没有跳跃性的移动，是稳定的排序。
【应用：常见面试题目】
Leetcode 148. Sort List
图解归并排序