基本排序算法（全）

7个基本排序算法：

冒泡，选择，插入
快排，归并，堆
桶
已实际运行过

冒泡：时间复杂度O(n^2)
选择：同上
插入：数据基本有序的情况下O(n)能达到桶排序速度，  平均和坏的时间复杂度为O(n^2)

快排： 平均性能比较好的O(nlog2N)
归并： 需要额外的空间辅助
堆：3个部件： 建堆，排序，下滑

桶：最快的，对某些特定问题，数据在一定范围内的。

import java.util.Arrays;
public class SortsDemo {
    public static int N=50000;  //数据的数目
    public static int M=10000; //数据的范围
    public static int[] data=new int[N];
    public static void main(String[] args){
        init();
        //printData();
        long startTime=System.currentTimeMillis();  //用于测试性能
        //O(n^2)
        //BubbleSort();
        //selectSort();
        //insetSort();
        //O(log2(N))
        //quickSort(0, data.length-1);
        //MergeSort(0, data.length-1);
        //HeapSort();
        //O(n)
        //bucketSort(); 
        //printData();
        System.out.println(System.currentTimeMillis()-startTime);
    }
    //数据初始化，随机生成数据
    public static void init()
    {
        for (int i = 0; i < data.length; i++) {
            data[i]=(int) (Math.random()*100);
        }
    }
    public static void BubbleSort(){
        for(int i=0;i<N-1;i++){
            for (int j = 0; j < N-i-1; j++) {
                if(data[j]>data[j+1])
                {
                    //交换2个数
                    data[j]=data[j]^data[j+1];
                    data[j+1]=data[j]^data[j+1];
                    data[j]=data[j]^data[j+1];
                }
            }
        }
    }

    public static void selectSort(){
        for(int i=0;i<N;i++){
            for (int j = i+1; j < N; j++) {
                if(data[i]>data[j])
                {
                    data[i]=data[i]^data[j];
                    data[j]=data[i]^data[j];
                    data[i]=data[i]^data[j];
                }
            }
        }
    }

    public static void insetSort(){
        int i,j;
        for (i = 1; i < data.length; i++) {
            int temp=data[i];
            for (j = i-1; j >=0; j--) {
                if(temp<data[j])
                {
                    data[j+1]=data[j];
                }else{
                    break;
                }
            }
            data[j+1]=temp;
        }

    public static void quickSort(int left,int right){
        if(left>right)
            return;
        int temp=data[left];//最左边的为基数，划分左右
        int i=left;
        int j=right;
        while(i!=j)
        {
            while(data[j]>=temp&&i<j)
            {
                j--;
            }
            while(data[i]<=temp&&i<j)
            {
                i++;
            }
            if(i<j)
            {
                data[i]=data[i]^data[j];
                data[j]=data[i]^data[j];
                data[i]=data[i]^data[j];

            }
        }
        data[left]=data[i];
        data[i]=temp;
        quickSort(left, i-1);
        quickSort(i+1, right);
        return;
    }

    public static void MergeSort(int m, int n){
        if (m != n) {
            int q = (m + n) / 2;
            MergeSort(m, q);
            MergeSort(q+1, n);
            Merge(m, n);
        }

    private static void Merge(int m, int n) {
        // TODO Auto-generated method stub
    //  System.out.println("--m"+m+"--n"+n);
        int q = (m + n) / 2;
        int[] left = new int[q - m+2 ];
        int[] right = new int[n - q+1];
        left[0]=0;
        right[0]=0;
        for (int i = 1; i < left.length; i++) {
            left[i]=data[i+m-1];
        }
        for (int i = 1; i < right.length; i++) {
            right[i]=data[i+q];
        }
        int i = 1;//新 左边数组
        int j = 1;//新右边数组
        int index = m;//原始数据数组索引
        while (i < left.length && j < right.length) {
            if (left[i] < right[j]) {
                data[index] = left[i];
                i++;
                index++;
            } else {
                data[index] = right[j];
                j++;
                index++;
            }
        }
        if (i < left.length) {
            while (i < left.length) {
                data[index] = left[i];
                index++;
                i++;
            }
        }
        if (j < right.length) {
            while (j < right.length) {
                data[index] = right[j];
                index++;
                j++;
            }
        }
    }

    public static void HeapSort(){
        int heapData[]=new int[data.length+1];
        for (int i = 1; i < heapData.length; i++) {
            heapData[i]=data[i-1];
        }
        for (int i = heapData.length/2; i>=1; i--) {
            //System.out.println("i"+i);
            swiftDown(heapData,i,heapData.length-1);
        }
        for (int i = 1; i <= heapData.length-1; i++) {
            int length=heapData.length-i;//边界索引

            //边界的数和第一个数交换
            heapData[1]=heapData[1]^heapData[length];
            heapData[length]=heapData[1]^heapData[length];
            heapData[1]=heapData[1]^heapData[length];

            swiftDown(heapData, 1, length-1);
        }
        //for (int i = heapData.length-1; i >= 1; i--) {
        //System.out.print(heapData[i]+",");
        //}
    }
    /**
     * @param heapData  数据
     * @param i  下滑数据索引
     * @param length  边界长度，即 有效数据
     */
    public static void swiftDown(int[] heapData,int i,int length)
    {
        //下滑操作

        int temp=heapData[i];
        int leftChild=2*i<=length?heapData[2*i]:Integer.MAX_VALUE;
        int rightChild=(2*i+1)<=length?heapData[2*i+1]:Integer.MAX_VALUE;
        if(leftChild<=rightChild){
            if(leftChild<=temp){
                heapData[i]=leftChild;
                heapData[2*i]=temp;
                swiftDown(heapData, 2*i,length);
            }
        }else{
            if(rightChild<=temp){
                heapData[i]=rightChild;
                heapData[i*2+1]=temp;
                swiftDown(heapData, 2*i+1,length);
            }
        }
    }
    public static void bucketSort(){
        int[] buckets=new int[M+1];
        for (int i = 0; i < buckets.length; i++) {
            buckets[i]=0;
        }
        for (int i = 0; i < N; i++) {
            buckets[data[i]]++;
        }
        //  for (int i = 0; i < buckets.length; i++) {
        //  for (int j = 0; j < buckets[i]; j++) {
        //  System.out.print(i+",");
        //    }
        //  }
    }

    public static void printData(){
        System.out.println(Arrays.toString(data));
    }
}