java实现：快速排序，基数排序，计数排序，归并排序，堆排序，希尔排序

import java.util.ArrayList;
import java.util.List;


public class Suanfa {
    static  int [] array={12,122,4,23,45,333,2,5};
    //快速排序：将数据分为左右两部分，左边都比右边小
    public static void QuakeSort(int [] a,int start,int end)
    {
        if(!(start<end))
            return;
        int temp=a[start];
        int i=start,j=end;
        while(i<j)
        {
            while(a[i]<temp && i<j)
                i++;
            while(a[j]>temp && j>i)
                j--;
            if(i<j)
            {
                int t=a[i];
                a[i]=a[j];
                a[j]=t;
            }
        }
        a[i]=temp;
        printArray();
        QuakeSort(a,start,i-1);
        QuakeSort(a,i+1,end);
    }
    //计数排序: 对每一个数出现的次数进行计数，然后从大到小输出这些数
    public static void CountSort(int[] a)
    {
        int max=a[0];
        for(int i=0;i<a.length;i++)
        {
            max=max>a[i]?max:a[i];
        }
        int []temp=new int[max+1];
        for(int i=0;i<a.length;i++)
        {
           temp[a[i]]+=1;
        }
        int t=0;
        for(int i=0;i<max;i++)
        {
            t=temp[i];
            while (t>0)
            {
                System.out.print(i+",");
                t--;
            }
        }
    }
    //基数排序：按照个位，十位百位分别排序
    public static  void JiShuSort(int[] a)
    {
        List<Integer> [] temp=new List[10];
        for (int i=0;i<10;i++)
        {
            temp[i]=new ArrayList<Integer>();
        }
        int max=a[0];
        for(int i=0;i<a.length;i++)
        {
            max=max>a[i]?max:a[i];
        }
        int k=0;
        while (max>10)
        {
            max=max/10;
            k++;
        }
        for(int i=0;i<=k;i++)
        {
            for(int j=0;j<a.length;j++)
            {
               int t= (int) (a[j]/(Math.pow(10,i))-(int)(a[j]/(Math.pow(10,i+1)))*10);
                temp[t].add(a[j]);
            }
            int tempdata=0;
            for(int j=0;j<10;j++)
            {
                while (temp[j].size()>0)
                {  a[tempdata++]=temp[j].get(0);
                    temp[j].remove(0);
                }
            }
            printArray();
        }

    }
    // 归并排序
    public static  void MergeSort(int[] a,int start,int end)
    {
        int middle=(start+end)/2;
        if(start<end)
        {
            MergeSort(a,start,middle);
            MergeSort(a,middle+1,end);
            Merge(a,start,end);
        }
    }
    public static  void Merge(int[] a,int start,int end)
    {
        int middle=(start+end)/2;
        int i=start;int j=middle+1;
        int [] temp=new int[end-start+1];
        int tempindex=0;
        while(i<j && i<=middle && j<=end)
        {
            if(a[i]<=a[j])
            {
                temp[tempindex++]=a[i];
                i++;
            }
            else
            {
                temp[tempindex++]=a[j];
                j++;
            }
        }
        while (i<=middle)
        {
            temp[tempindex++]=a[i];
            i++;
        }
        while (j<=end)
        {
            temp[tempindex++]=a[j];
            j++;
        }
        for( i=0;i<temp.length;i++)
        {
            a[start+i]=temp[i];
        }
    }
    //堆排序：每次将最顶端的数和最后面的数交换，然后对除了最后面的数的堆进行调整
    private static  void HeapSort(int[] a)
    {
        for(int i=a.length/2;i>=0;i--)
        {
            HeapAdjust(a,i,a.length-1);
        }
        int temp=0;
        printArray();
        for(int i=array.length-1;i>=0;i--)
        {
            temp=a[0];
            a[0]=a[i];
            a[i]=temp;
            HeapAdjust(a,0,i-1);
            printArray();
        }
    }
    private static void HeapAdjust(int[] a,int start,int end)
    {
        int i=start*2+1;
        int j=start*2+2;
        int temp=-1;
        if(i<=end)
            temp=i;
        if(j<=end && a[j]>a[i])
            temp=j;
        if(temp>=0 && a[start]<a[temp])
        {
            int tempdata=a[temp];
            a[temp]=a[start];
            a[start]=tempdata;
            HeapAdjust(a,temp,end);
        }

    }
    private static  void ShellSort(int[] a)
    {
        int d=a.length;
        while(d>=1)
        {
            for(int i=0;i<d;i++)
            {
                for(int j=i;j<a.length;j+=d)
                {
                    int maxj=j;
                    for(int k=j;k<a.length;k+=d)
                    {
                        maxj=a[maxj]>=a[k]?maxj:k;
                    }
                    int temp=a[j];
                    a[j]=a[maxj];
                    a[maxj]=temp;
                }
            }
            d=d/2;
            printArray();
        }

    }
    public static  void main(String[] args)
    {
        System.out.println("start");
       // QuakeSort(array,0,array.length-1);
       // CountSort(array);
        //JiShuSort(array);
       // MergeSort(array,0,array.length-1);
      //  ShellSort(array);
        HeapSort(array);
        printArray();
        System.out.println("end");
    }
    private static void printArray()
    {
        System.out.println();
        for(int i=0;i<array.length;i++)
        {
            System.out.print(array[i]+",");
        }
    }
}