一、归并排序
(一)自顶向下的归并排序
1、思路
还是很好理解的哦
- 将一个待排序的数进行拆分成两个数组。
- 然后对左边的数组进行递归,进行归并,最后得到一个左边的有序数组【在这内部也进行的内部的拆分为两个小数组,进行排序归并】。
- 然后对右边的数组进行递归,进行归并,最后得到一个右边的有序数组【在这内部也进行的内部的拆分为两个小数组,进行排序归并】。
- 最后将两个数组进行进行归并。
2、代码实现
代码阅读建议
- 首先去看Merge类里面的merge方法,理解它的含义了
- 去整体的看一遍Merge里面的所有排序方法的实现
- 最后去看测试
import java.util.Arrays;
public class MergeSort {
public static void main(String[] args) {
String[] a = {"A","E","B","D","M"};
Merge merge = new Merge();
merge.sort(a);
System.out.println(Arrays.toString(a));
}
}
class Merge {
private static Comparable[] aux;
public static void sort(Comparable[] a) {
aux = new Comparable[a.length];
sort(a,0,a.length-1);
}
private static void sort(Comparable[] a, int lo, int hi) {
if (hi <= lo) {
return;
}
int mid = (lo + hi) / 2;
sort(a,lo,mid);//像左递归
sort(a,mid + 1,hi);//向右边递归
merge(a,lo,mid,hi);//归并
}
public static void merge(Comparable[] a,int lo,int mid,int hi) {
int i = lo;
int j = mid + 1;
for (int k = lo; k <= hi; k++) {
aux[k] = a[k];
}
for (int k = lo; k <= hi; k++) {
if (i > mid) {//如果左边用尽
a[k] = aux[j++];
} else if (j > hi) {//如果右边用尽
a[k] = aux[i++];
} else if (less(aux[j],aux[i])){//如果当前点左边的大于有边的元素的情况下
a[k] = aux[j++];
} else {//如果当前点右边的元素大于左边当前的情况下
a[k] = aux[i++];
}
}
}
//这方法是判断的如果v < w则返回true
private static boolean less(Comparable v, Comparable w) {
return v.compareTo(w) < 0;
}
private static void exch(Comparable[] a,int i, int j) {
Comparable t = a[i];
a[i] = a[j];
a[j] = t;
}
}
3、时间复杂度和流程图
- 时间复杂度的推导
时间复杂度为1/2N lgN 到 N lgN次比较【详细见下面的推导过程】
- 流程图
4、测试一下性能
(1)没改进版测试
它的性能跟我们之前的的两种算法都没得比,这个好啦很多,所以把数据调大。
public static void main(String[] args) {
int N = 800000;
Integer[] j = new Integer[N];
for (int i = 0; i < N; i++) {
j[i] = (int)Math.random()*N;
}
/*for (int k = 0; k < 80000; k++) {
for (int i = 80000; i > 0; i--) {
j[k] = i;
}
}*/
long l = System.currentTimeMillis();
new Merge().sort(j);
long e = System.currentTimeMillis();
System.out.println("所用时间为:" + (e - l));
}
(2)改进版测试
在这个方法上来一个判断【省去了一次递归】
private static void sort(Comparable[] a, int lo, int hi) {
if (hi <= lo) {
return;
}
int mid = (lo + hi) / 2;
sort(a,lo,mid);//像左递归
sort(a,mid + 1,hi);//向右边递归
if (less(a[mid + 1],a[mid])) {
merge(a,lo,mid,hi);//归并
}
}
(二)自底向上的归并
1、思路实现
你看我的分析
- 首先得理解上面的自顶向下的设计思路,它是先将大的数组分解为两个,然后再将分得到的子数组分为两个。递归下去。
- 而自底向上的是先将个两个元素进行归并排序,然后再将4个数据进行归并排序,然后再将8个进行归并,然后再将18个等等下去,最后只有两个进行归并。
- 另外性能测试的话你可以自己试一下。
2、代码实现
class MergeBu {
private static Comparable[] aux;
public static void sort(Comparable[] a) {
int N = a.length;
aux = new Comparable[N];
for (int sz = 1; sz < N; sz = sz + sz) {
for (int lo = 0; lo < N - sz; lo += sz + sz) {
merge(a,lo,lo+sz + 1,Math.min(lo+sz+sz-1,N-1));
}
}
}
public static void merge(Comparable[] a,int lo,int mid,int hi) {
int i = lo;
int j = mid + 1;
for (int k = lo; k <= hi; k++) {
aux[k] = a[k];
}
for (int k = lo; k <= hi; k++) {
if (i > mid) {//如果左边用尽
a[k] = aux[j++];
} else if (j > hi) {//如果右边用尽
a[k] = aux[i++];
} else if (less(aux[j],aux[i])){//如果当前点左边的大于有边的元素的情况下
a[k] = aux[j++];
} else {//如果当前点右边的元素大于左边当前的情况下
a[k] = aux[i++];
}
}
}
//这方法是判断的如果v < w则返回true
private static boolean less(Comparable v, Comparable w) {
return v.compareTo(w) < 0;
}
private static void exch(Comparable[] a,int i, int j) {
Comparable t = a[i];
a[i] = a[j];
a[j] = t;
}
}