归并排序是面试中比较常见的一种排序算法,之前面试官问的时候,答得总是很浅,今天将其总结如下,希望下次回答的令人满意。
归并排序的思想:采用分治的思想,具体步骤如下
归并操作(merge),也叫归并算法,指的是将两个顺序序列合并成一个顺序序列的方法。
如 设有数列{10,4,6,3,8,2,5,7}
初始状态:10,4,6,3,8,2,5,7
第一次归并后:{4,10},{3,6},{2,8},{5,7}
第二次归并后:{3,4,6,10},{2,5,7,8}
第三次归并后:{2,3,4,5,6,7,8,10}
归并排序的代码实现,具体可以从下面几个方面来答:
最基础的实现:
public class MergeSort1 {
public static void main(String[] args) {
int[] a = {3, 1, 7, 8, 9, 2, 3, 1, 10, -1};
mergeSort(a, 0, a.length - 1);
for (int i : a) {
System.out.print(i + " ");
}
}
/**
* 分的时候,直到当前分的段中只剩一个元素
* @param a
* @param l
* @param r
*/
private static void mergeSort(int[] a, int l, int r) {
if (l >= r) {
return;
}
int mid = (l + r) / 2;
mergeSort(a, l, mid);
mergeSort(a, mid + 1, r);
merge(a, l, mid, r);
}
/**
* 合并,相当于是两个升序有序数组合并为一个升序数组,在这里需要借助一个辅助的数组,保存排好序的数组
* 最后将其赋值到原数组对应的位置
* @param a
* @param l
* @param mid
* @param r
*/
private static void merge(int[] a, int l, int mid, int r) {
int[] temp = new int[r - l + 1];
int i = l, j = mid + 1;
int p = 0;
while (i <= mid && j <= r) {
temp[p++] = a[i] < a[j] ? a[i++] : a[j++];
}
while (i <= mid) {
temp[p++] = a[i++];
}
while (j <= r) {
temp[p++] = a[j++];
}
int tempIndex = 0;
while (tempIndex < temp.length) {
a[l++] = temp[tempIndex++];
}
}
}
简单优化1--合并时加if条件判断
在这里对于mergeSort函数加上了if条件的判断,因为当两个数组本身就是有序的情况下,合并后的结果不变,所以这种情况可以不用做合并
优化2--对于一定长度的段,使用插入排序
虽然插入排序的时间复杂度是o(n^2),归并排序的时间复杂度是o(nlogn),但是这个个时间复杂度本身的基数是不一样的,详细地说,插入排序的时间复杂度是o(n^2/4+n/2-1/2),归并排序的时间复杂度是o(nlogn+n),关于其时间复杂度求解:
https://www.cnblogs.com/zhangtebie/p/11185874.html https://www.cnblogs.com/sheeva/p/6600666.html
有这两个表达式可见,当n较小的时候,插入的时间复杂度小于归并排序,下面的代码中,对于长度小于等于15的段,使用了插入排序(不一定是15,可以自行计算)
public class MergeSort2 {
public static void main(String[] args) {
int[] a = {3, 1, 7, 8, 9, 2, 3, 1, 10, -1, 1, 8, 7, 4, 3, 2,1};
mergeSort(a, 0, a.length - 1);
for (int i : a) {
System.out.print(i + " ");
}
}
/**
* 当分段后的当前数组的长度小于等于15的时候,采用插入排序
* @param a
* @param l
* @param r
*/
private static void mergeSort(int[] a, int l, int r) {
if (r - l <= 15) {
InsertSort(a, l, r);
return;
}
int mid = (l + r) / 2;
mergeSort(a, l, mid);
mergeSort(a, mid + 1, r);
merge(a, l, mid, r);
}
/**
* 两个升序数组合并为一个升序数组
* @param a
* @param l
* @param mid
* @param r
*/
public static void merge(int[] a, int l, int mid, int r) {
int i = l, j = mid + 1;
int[] temp = new int[r - l + 1];
int p = 0;
while (i <= mid && j <= r) {
temp[p++] = a[i] < a[j] ? a[i++] : a[j++];
}
while (i <= mid) {
temp[p++] = a[i++];
}
while (j <= r) {
temp[p++] = a[j++];
}
int tempIndex = 0;
while (tempIndex < temp.length) {
a[l++] = temp[tempIndex++];
}
}
/**
* 直接插入排序
* @param a
* @param start
* @param end
*/
private static void InsertSort(int[] a, int start, int end) {
int i, j;
for (i = start + 1; i <= end; i++) {
int temp = a[i];
for (j = i - 1; j > -1 && a[j] > temp; j--) {
a[j + 1] = a[j];
}
a[j + 1] = temp;
}
}
}
优化三--不使用递归,采用自底向上的方法
对于自定向上的方法,基本思想是给定一个size,初始值为0,第一次对[0,1][1,2][3,4]所在的坐标对应的元素进行排序,然后size依次增大为2,4,8,...(这种思想相当于没有分的过程,借用size,直接进行合并的过程)
public class MergeSort3 {
public static void main(String[] args) {
int[] a = {3, 1, 7, 8, 9, 2, 3, 1, 10, -1, 1, 8, 7, 4, 3, 2};
mergeSort(a);
for (int i : a) {
System.out.print(i + " ");
}
}
private static void mergeSort(int[] a) {
//size依次增大为1,2,4,8,...要保证小于等于数组的长度
for (int size = 1; size <= a.length; size *= 2) {
//要考虑到i+size越界的情况,所以i+size<length,考虑到i+size+size-1越界的情况,所以求其与a.length-1的最小值
for (int i = 0; i + size < a.length; i += 2 * size) {
MergeSort2.merge(a, i, i + size - 1, Math.min(i + size + size - 1, a.length - 1));
}
}
}
}