归并排序
1. 基本原理
归并排序算法是分治策略实现对n个元素进行排序的算法。
其基本思想是：将待排序元素分成大小大致相同的2个子集合，分别对2个子集合进行排序，最终将排好序的子集合合并成为所要求的排好序的集合。
2. 算法步骤
- 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列
- 设定两个指针，最初位置分别为两个已经排序序列的起始位置
- 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置
- 重复步骤3直到某一指针到达序列尾
- 将另一序列剩下的所有元素直接复制到合并序列尾
3. 算法图解
详情请参考 https://www.cnblogs.com/chengxiao/p/6194356.html
采用经典的分治（divide-and-conquer）策略（分治法将问题分解成规模更小、解法相同的子问题，然后通过子问题的解构造出原问题的解)。
分阶段是递归拆分子序列的过程，递归深度为.
对于治阶段，需要将两个已经有序的子序列合并成一个有序序列，例如上图中的最后一次合并，要将[4,5,7,8]和[1,2,3,6]两个已经有序的子序列，合并为最终序列[1,2,3,4,5,6,7,8]，具体实现步骤如下:
4. 动画演示
5. 参考实现
import java.util.Arrays;
/**
* @author wylu
*/
public class MergeSort {
public static void merge(int[] arr, int left, int mid, int right, int[] tmp) {
int i = left, j = mid + 1, t = 0;
while (i <= mid && j <= right) tmp[t++] = (arr[i] <= arr[j]) ? arr[i++] : arr[j++];
while (i <= mid) tmp[t++] = arr[i++];
while (j <= right) tmp[t++] = arr[j++];
t = 0;
while (left <= right) arr[left++] = tmp[t++];
}
//递归
public static void recursiveSort(int[] arr, int left, int right, int[] tmp) {
if (left < right) {
int mid = (left + right) / 2;
recursiveSort(arr, left, mid, tmp);
recursiveSort(arr, mid + 1, right, tmp);
merge(arr, left, mid, right, tmp);
}
}
//非递归
public static void nonRecursiveSort(int[] arr) {
int[] tmp = new int[arr.length];
for (int size = 1; size < arr.length; size *= 2) {
int left, mid, right;
for (left = 0; left + size < arr.length; left = right + 1) {
mid = left + size - 1;
right = Math.min(mid + size, arr.length - 1);
merge(arr, left, mid, right, tmp);
}
}
}
public static void main(String[] args) {
int[] arr = {3, 1, 4, 9, 6, 0, 7, 2, 5, 8};
// MergeSort.recursiveSort(arr, 0, arr.length - 1, new int[arr.length]);
MergeSort.nonRecursiveSort(arr);
System.out.println(Arrays.toString(arr));
}
}
6. 复杂度分析
| 排序算法 | 平均时间复杂度 | 最好情况 | 最坏情况 | 空间复杂度 | 排序方式 | 稳定性 |
|---|---|---|---|---|---|---|
| 归并排序 | Out-place | 稳定 |
7. References
图片来源
https://www.cnblogs.com/chengxiao/p/6194356.html