排序算法（java）

1、选择排序

public class Selection{
    public static sort(Comparable[] a){
            int N = a.length;
            for(int i = 0; i<N; i++){
                    int min = i;
                    for(int j + i+1; j<N;j++){    
                          if(less(a[i],a[j])) min = j;
                    }
                    exch(a,i min);
               }
}
}

                        

 2、插入排序

public class Insertion{
    public static sort(Comparable[] a){
            int N = a.length;
            for(int i = 1; i<N; i++){
                   for(int j = i; j>0&&less(a[j],a[j-1]); j--){
                        exch(a, j, j-1);
                   }
         }
}
}

3、希尔排序

如果你需要解决一个排序问题而又没有系统排序函数可用，可以先用希尔排序，然后再考虑是否值得将它替换为更加复杂的排序算法。

public class Shell{
    public static sort(Comparable[] a){
            int N = a.length;
            int h = 1;
            while(h<N/3) h=3*h+1;//1,4,13,40,121...
    
            while(h>= 1){
                    for(int i = h; i<N; i++){
                        for(int j = i; j>=h && less(a[j], a[j-h]); j -= h){
                            exch(a, j, j-h);
                }
            }
}
}

 

4、归并排序

//自顶向下的归并排序
public class Merge{
    private static Comparable[] aux;
    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(lo>=hi) return;
        int mid = lo + (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, 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++];
}
}

//自底向上的归并排序
public class MergeBu{
    private 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));
            }
        }
}
}

5、快速排序

public class Quick{
    public static void sort(Comparable[] a){
            StdRandom.shuffle(a); //消除对输入的依赖，打乱数组顺序
            sort(a, 0, a.length -1);
    }
    public static void sort(Comparable[] a, int lo, int hi){
            if(hi <= lo) return;
            int j = partition(a, lo, hi);
            sort(a, lo, j);
            sort(a, j+1, hi);
    }
    public static int partition(Comparable[] a, int lo, int hi){
            int i = lo, j =hi+1 //左右扫描指针
            Comparable v = a[lo];
            while(true)
            {
                while(less(a[++i], v)) if(i == hi) break;
                while(less(a[--j], v)) if(j == lo) break;
                if(i >= j) break;
                exch(a, i, j);
              }
            exch(a, lo, j)
            return j;
}
}