Java排序

排序的例程写过N多次

老是记不住，所以决定还是写下来好随时看看

以下例程参照Java数据结构与算法分析第二版

//TODO

package com.company.sort;

/**
 * Created by Administrator on 2017/5/26.
 */
public class sortDemo01<E> {
    private static final int CUTOFF = 20;

    public static <E extends Comparable<? super E>> void insertionSort(E[] a){
        int j;
        for (int p=1;p<a.length;p++){
            E tmp=a[p];
            for (j=p;j>0&&tmp.compareTo(a[j-1])<0;j--){
                a[j]=a[j-1];
                System.out.println(a);
            }
            a[j]=tmp;
        }
    }

    public static <E extends Comparable<? super E>> void shellSort(E[] a){
        int j;
        for (int gap=a.length/2;gap>1;gap /=2){
            for (int i=gap;i<a.length;i++){
                E tmp=a[i];
                for (j=i;j>=gap&&tmp.compareTo(a[j-gap])<0;j-=gap)
                    a[j]=a[j-gap];
                a[j]=tmp;
            }
        }
    }

    public static <E extends Comparable<? super E>> void mergeSort(E[] a){
        E[] tmp= (E[]) new Comparable[a.length];
        mergeSort(a,tmp,0,a.length-1);
    }

    private static <E extends Comparable<? super E>>void mergeSort(E[] a, E[] tmp, int left, int right) {
        if (left<right){
            int center=(left+right)/2;
            mergeSort(a,tmp,left,center);
            mergeSort(a,tmp,center+1,right);
            merge(a,tmp,left,center+1,right);
        }
    }

    private static <E extends Comparable<? super E>> void merge(E[] a, E[] tmp, int leftPos, int rightPos, int rightEnd) {
        int leftEnd=rightPos-1;
        int tmpPos=leftPos;
        int numElements=rightEnd-leftPos+1;

        //Main loop
        while(leftPos<=leftEnd&&rightPos<=rightEnd){
            if (a[leftPos].compareTo(a[rightPos])<=0)
                tmp[tmpPos++]=a[leftPos++];
            else
                tmp[tmpPos++]=a[rightPos++];
        while (leftPos<=leftEnd)        //Copy rest of first half
            tmp[tmpPos++]=a[leftPos++];
        while(rightPos<=rightEnd)       //Copy rest of right half
            tmp[tmpPos++]=a[rightPos++];
        //Copy tmp back
        for (int i=0;i<numElements;i++,rightEnd--)
            a[rightEnd]=tmp[rightEnd];
        }
    }

    public static <E extends Comparable<? super E>> void quickSort(E[] a){
        quickSort(a,1,a.length-1);
    }

    private static <E extends Comparable<? super E>> void quickSort(E[] a, int left, int right) {
        if (left + CUTOFF <= right) {
            E pivot = median3(a, left, right);

            //Begin partitioning
            int i = left, j = right - 1;
            for (; ; ) {
                while (a[++i].compareTo(pivot) < 0) {
                }
                while (a[--j].compareTo(pivot) < 0) {
                }
                if (i<j)
                    swapreference(a,i,j);
                else
                    break;
            }
            swapreference(a,i,right-1);//Restore pivot
            quickSort(a,left,i-1);//Sort small elements
            quickSort(a,i+1,right);//Sort large elements
        }
        else    //Do a insertion sort on the subarray
            insertionSort(a);
    }

    private static <E extends Comparable<? super E>> E median3(E[] a, int left, int right) {
        int center=(left+right)/2;
        if (a[center].compareTo(a[left])<0)
            swapreference(a,left,center);
        if (a[right].compareTo(a[left])<0)
            swapreference(a,left,right);
        if (a[right].compareTo(a[center])<0)
            swapreference(a,center,right);

        swapreference(a,center,right-1);
        return a[right-1];
    }

    private static <E extends Comparable<? super E>> void swapreference(E[] a, int left, int right) {
        E tmp=a[left];
        a[left]=a[right];
        a[right]=tmp;
    }

    public static <E extends Comparable<? super E>> void percDown(E[] a,int i,int n){
        int child;
        E tmp;
        for (tmp=a[i];leftChild(i)<n;i=child){
            child=leftChild(i);
            if (child!=n-1&&a[child].compareTo(a[child+1])<0)
                child++;
            if (tmp.compareTo(a[child])<0)
                a[i]=a[child];
            else
                break;
        }
        a[i]=tmp;
    }

    private static int leftChild(int i){
        return 2*i+1;
    }

    public static <E extends Comparable<? super E>> void heapSort(E[] a){
        for (int i=a.length/2;i>=0;i--)
            percDown(a,i,a.length);
        for (int i = a.length-1; i >0 ; i--) {
            swapreference(a, 0, i);
            percDown(a, 0, i);
        }
    }

}