排序算法汇总

import java.util.concurrent.Callable;

public class InsertSort0703//<T extends Comparable<? super T>> 
{
    public static Integer[] a=
            new Integer[]{31,23,12,24,9,43,1,3,10,20,31,4,13,5,4,54,99,10,32,95,42};

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


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

    public static <T extends Comparable<? super T>>
    void HeapSort(T[] a)
    {
        for(int i=a.length/2;i>-1;i--)
            percolateDown(a,i,a.length);

        for(int i=0;i<a.length-1;i++)
        {
            swap(a, 0, a.length-1-i);
            percolateDown(a, 0, a.length-1-i);
        }
    }

    private static <T extends Comparable<? super T>>
    void percolateDown(T[] a, int hole, int length) 
    {
        T tmp=a[hole];
        int j,child;
        for(j=hole;j*2+1<length;j=child)
        {
            child=j*2+1;
            if(child+1<length && a[child+1].compareTo(a[child])>0)
                child++;
            if(a[child].compareTo(tmp)>0    )
                a[j]=a[child];
            else
                break;
        }
        a[j]=tmp;
    }
    public static  <T extends Comparable<? super T>>
    void mergeSort(T[] a)
    {
        T[] tmp=(T[])new Comparable[a.length];
        mergeSort(a,tmp,0,a.length-1);
    }
    private static <T extends Comparable<? super T>>
    void mergeSort(T[] a, T[] 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 <T extends Comparable<? super T>>
    void merge(T[] a, T[] tmp, int left, int right, int rightEnd) 
    {
        int elementNum=rightEnd-left+1;
        int leftEnd=right-1;
        int tmpPos=left;

        while(left<=leftEnd && right<=rightEnd)
            if(a[left].compareTo(a[right])<0)
                tmp[tmpPos++]=a[left++];
            else 
                tmp[tmpPos++]=a[right++];

        while(left<=leftEnd)
            tmp[tmpPos++]=a[left++];

        while(right<=rightEnd)
            tmp[tmpPos++]=a[right++];

        for(int i=0;i<elementNum    ;i++,rightEnd--)
            a[rightEnd]=tmp[rightEnd];
    }
    public static void main(String[] args) 
    {
        insertSort(a);
        for (Integer integer : a) 
            System.out.print(integer+" ");

    }
    public static <T extends Comparable<? super T>>
    void quicksort(Integer[] a) 
    {
        quicksort(a,0,a.length-1);

    }
    private static <T extends Comparable<? super T>>
    void  swap(T[] a,int idx1,int idx2)
    {
        T tmp=a[idx1];
        a[idx1]=a[idx2];
        a[idx2]=tmp;
    }
    private static <T extends Comparable<? super T>>
    T median3(T[] a,int left,int right)
    {
        int center=(right+right)/2;
        if(a[center].compareTo(a[left])<0)
            swap(a, center, left);
        if(a[right].compareTo(a[left])<0)
            swap(a, left, right);
        if(a[right].compareTo(a[center])<0)
            swap(a, center, right);
        swap(a, center, right-1);
        return a[right-1];
    }
    private static <T extends Comparable<? super T>>
    void quicksort(T[] a, int left, int right)
    {
        if(left+3>right)
        {
            T point=median3(a, left, right);
            int i=left,j=right-1;

            while(true)
            {
                while(a[++i].compareTo(point)<0);
                while(a[--j].compareTo(point)>0);
                if(i<j)
                    swap(a, i, j);
                else
                    break;
            }
        }
        else
        {
            insertSort(a,left,right);
        }

    }
    private static <T extends Comparable<? super T>>
    void insertSort(T[] a, int left, int right)
    {
        for(int p=1;p<right-left+1;p++)
        {
            int i;
            T tmp=a[left+p];
            for(i=left+p;i>left && tmp.compareTo(a[i-1])<0;i--)
                a[i]=a[i-1];
            a[i]=tmp;
        }   
    }
}