归并排序的泛型接口实现

还是很好理解的哦

• 将一个待排序的数进行拆分成两个数组。
• 然后对左边的数组进行递归，进行归并，最后得到一个左边的有序数组【在这内部也进行的内部的拆分为两个小数组，进行排序归并】。
• 然后对右边的数组进行递归，进行归并，最后得到一个右边的有序数组【在这内部也进行的内部的拆分为两个小数组，进行排序归并】。
• 最后将两个数组进行进行归并。

代码阅读建议

• 首先去看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;
    }
}

• 时间复杂度的推导
  时间复杂度为1/2N lgN 到 N lgN次比较【详细见下面的推导过程】
  
• 流程图
  

它的性能跟我们之前的的两种算法都没得比，这个好啦很多，所以把数据调大。

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;
        }
        
        long l = System.currentTimeMillis();
        new Merge().sort(j);
        long e = System.currentTimeMillis();
        System.out.println("所用时间为：" + (e - l));

    }

在这个方法上来一个判断【省去了一次递归】

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);//归并
        }
    }

你看我的分析

• 首先得理解上面的自顶向下的设计思路，它是先将大的数组分解为两个，然后再将分得到的子数组分为两个。递归下去。
• 而自底向上的是先将个两个元素进行归并排序，然后再将4个数据进行归并排序，然后再将8个进行归并，然后再将18个等等下去，最后只有两个进行归并。
• 另外性能测试的话你可以自己试一下。

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;
    }

}