基本排序算法（全）

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));
    }
}