排序算法（2）-优快云博客

本文链接：https://blog.youkuaiyun.com/hmh13548571896/article/details/78312549

本文介绍归并排序和快速排序两种经典排序算法的Java实现。归并排序包括自顶向下和自底向上两种方式，并给出具体代码示例。同时，文章提供了快速排序的递归实现，并对比了归并排序与希尔排序的性能。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

归并排序(自顶向下)

public class Merge{

    private static Comparable[] aux; //辅助数组j

    public static void sort(Comparable[] a){
        aux = new Comparable[a.length];
        sort(a, 0, a.length - 1);
    }

    public static void sort(Comparable[] a, int lo, int hi){
        if(hi <=lo)
            return;
        int mid = lo + (hi - lo)/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, 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(aux[j].compareTo(a[i]) < 0)
                a[k] = aux[j++];
            else
                a[k] = aux[i++];
        }
    }
}

归并排序(自底向上)

public class MergeBU{
    private static Comparable[] aux;

    public static void merge(Comparable[] a, int lo, int mid, int hi){
        int i = lo, 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(aux[j].compareTo(a[i]) < 0)
                a[k] = aux[j++];
            else
                a[k] = aux[i++];
        }
    }

    public static void sort(Comparable[] a){
        int N = a.length;
        aux = new Comparable[N];
        for(int sz = 1; sz < N; sz*=2){
            for(int lo = 0; lo < N - sz; lo += sz+sz)
                merge(a, lo, lo+sz-1, Math.min(lo+sz+sz-1, N-1));
        }
    }
}

在我电脑上用归并排序测试排序1000W个随机数大概需要2秒，而用希尔排序大概需要18秒。

快速排序

public class Quick{
    private static int partition(Comparable[] a, int lo, int hi){
        int i = lo, j = hi+1;
        Comparable v = a[lo];
        while(true){
            while(a[++i].compareTo(v) < 0)
                if(i == hi) break;
            while(v.compareTo(a[--j]) < 0)
                if(j == lo) break;
            if(i >= j) break;
            exch(a, i, j);
        }
        exch(a, lo, j);
        return j;
    }

    private static void exch(Comparable[] a, int i, int j){
        Comparable temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }

    public static void sort(Comparable[] a){
        sort(a, 0, a.length - 1);
    }

    private static void sort(Comparable[] a, int lo, int hi){
        if(hi <= 0)return;
        int j = partition(a, lo, hi);
        sort(a, lo, j-1);
        sort(a, j+1, hi);
    }
}