1、介绍
归并排序(MERGE-SORT)是利用归并的思想实现的排序方法,该算法采用经典的分治(divide-and-conquer)
策略(分治法将问题分(divide)成一些小的问题然后递归求解,而治(conquer)的阶段则将分的阶段得到的各答案"修
补"在一起,即分而治之)。
2、算法分析
(1)分解:每次把数组分均分为两份,利用递归的方法分解数组,直至每个小数组为1个大小。
(2)合并相邻有序子序列:再来看看治阶段,将两个已经有序的子序列合并成一个有序序列,比如上图中的最后一次合并,要将[4,5,7,8]和[1,2,3,6]两个已经有序的子序列,合并为最终序列[1,2,3,4,5,6,7,8],来看下实现步骤
3、代码实现
package com.czq.algorithm;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
/**
* 归并排序
*
* @author czq
* @date 2020/07/15
*/
public class MergetSort {
public static void main(String[] args) {
//测试排序的执行速度
//创建要给 8000000 个的随机的数组
int[] arr = new int[8000000];
for (int i = 0; i < arr.length; i++) {
// 生成一个[0, 8000000) 数
arr[i] = (int) (Math.random() * 8000000);
}
// int arr[] = {8, 4, 5, 7, 1, 3, 6, 2};
System.out.println("============排序前===============");
// System.out.println("排序后:" + Arrays.toString(arr));
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
System.out.println("排序前时间:" + sdf.format(new Date()));
//归并排序需要一个同样大小的额外空间
int temp[] = new int[arr.length];
mergeSort(arr, 0, arr.length - 1, temp);
System.out.println("============排序后===============");
System.out.println("排序前时间:" + sdf.format(new Date()));
// System.out.println("排序后:" + Arrays.toString(arr));
}
/**
* 分解+合并
*
* @param arr 排序的原始数组
* @param left 左边有序序列的初始索引
* @param right 右边索引
* @param temp 中转的数组
*/
private static void mergeSort(int[] arr, int left, int right, int[] temp) {
//当只有一个元素时不能再分解
if (left < right) {
//中间索引
int mid = (left + right) / 2;
//向左递归进行分解
mergeSort(arr, left, mid, temp);
//向右递归进行分解
mergeSort(arr, mid + 1, right, temp);
//合并
merge(arr, left, mid, right, temp);
}
}
/**
* 合并
*
* @param arr 排序的原始数组
* @param left 左边有序序列的初始索引
* @param mid 中间索引
* @param right 右边索引
* @param temp 做中转的数组
*/
private static void merge(int[] arr, int left, int mid, int right, int[] temp) {
int i = left,//初始化 i, 左边有序序列的初始索引
j = mid + 1,//初始化 j, 右边有序序列的初始索引
t = 0;// 指向 temp 数组的当前索引
//(一)
//先把左右两边(有序)的数据按照规则填充到 temp 数组
//直到左右两边的有序序列,有一边处理完毕为止
while (i <= mid && j <= right) {
if (arr[i] <= arr[j]) {
temp[t++] = arr[i++];
} else {
temp[t++] = arr[j++];
}
}
//(二)
//把有剩余数据的一边的数据依次全部填充到
while (i <= mid) {//左边的有序序列还有剩余的元素,就全部填充到 temp
temp[t++] = arr[i++];
}
while (j <= right) {//右边的有序序列还有剩余的元素,就全部填充到
temp[t++] = arr[j++];
}
//(三)
//将 temp 数组的元素拷贝到 arr
//注意,并不是每次都拷贝所有
t = 0;
//第一次合并 left = 0 , right = 1 // left = 2 right = 3 // left=0 right=3 //最后一次 tempLeft = 0 right = 7
while (left <= right) {
arr[left++] = temp[t++];
}
}
}
结果:800000长度的数组排序时间需要0-1s,时间复杂度O(nlogn),空间复杂度O(n)
8000000长度的数组排序时间需要1-2s
80000000长度的数组排序时间需要14~15s