1、氣泡排序

原理：
比較array[n]和array[n+1]的大小，把大的數交換到後面，即array[n]>array[n+1]，就交換。迴圈到陣列最後，就可以把最大值找出來，放到array[length-1]上。
第二次迴圈，把第二大的數交換到array[length-2]上面
迴圈n-1次就把最大的n-1個數找出來，最小的數就在array[0]處。
為了方便，這裡把交換的函式抽出來，如下，後面的幾個排序也會用到這個交換。

   //氣泡排序
   public static void bubbleSort(int[] array){
        for(int i = 0
 
,len = array.length-1;i<len;i++){
            for(int j = 0;j<len-i;j++){
                if(array[j]>array[j+1]){
                    swap(array,j,j+1);
                }
            }
        }
    }

   //交換陣列中a位置和b位置的數
   public static void swap(int[] array,int a,int b){
        if(a!=b){
            array[a] = array[a] + array[b];
            array[b] = array[a] - array[b];
            array[a] = array[a] - array[b];
        }
    }
 

2、直接插入排序

原理：
確認array[n]的前面的數值都比array[n]小。
第一次，比較array[0]和array[1]，把小的數交換到前面
第二次，比較array[2]和它前面的資料，放到合適的位置。
迴圈到最後，排序完成

 /**
     * 直接插入排序
     * @param array
     */
    public static void insertSort(int[] array){
        int temp;
        for(int i = 1,len = array.length;i<len;i++){
            int
 
 j = i-1;
            temp = array[i];
            for(;j>=0&&temp<array[j];j--){
                array[j+1] = array[j];
            }
            array[j+1] = temp;
        }
    }

3、希爾排序（直接插入改進）

原理：
希爾排序是把陣列根據希爾值分成n個部分,進行排序，再把間隔減小，再排序，最後間隔為1，再排序整個陣列就是有序的。
如：
陣列長度為10，預設的希爾值是2，也可以直接根據情況選擇其它數字。
當希爾值為2時，間隔為10/2=5,把陣列分成位置在[0,5],[1,6],[2,7],[3,8],[4,9]五個部分，對這五個分別進行排序，然後把上一次的間隔5/2(希爾值)=2作為間隔，分成[0,2,4,6,8]和[1,3,5,7,9]兩個部分。分別進行排序。最後間隔為2/2=1，也就是整個陣列進行直接插入排序。

/**
     * 希爾交換排序
     * @param array
     * @param init
     */
    public static void shellSortSwap(int[] array,int init){
        for(int temp = array.length/init;temp>0;temp/=init){
            for(int i = temp;i<array.length;i++){
                int j = i;
                while(j-temp>0&&array[j]<array[j-temp]){
                    swap(array,j,j-temp);
                    j-=temp;
                }
            }
        }
    }

4、選擇排序

原理：依次選出最小的數放到前面
第一次，從位置0開始找出最小的數,記錄位置，把最小的數與位置0的數進行交換
第二次，從位置1開始………..。

/**
     * 選擇排序
     * @param array
     */
    public static void chooseSort(int[] array){
        int position;
        for(int i = 0,len = array.length;i<len;i++){
            int temp = array[i];
            position = i;
            for(int j = i+1;j<len;j++){
                if(temp>array[j]){
                    temp = array[j];
                    position = j;
                }
            }
            swap(array,i,position);
        }
    }

5、快速排序

原理：
1、先從數列中取出一個數作為基準數
2、分割槽過程，將比這個數大的數全放到它的右邊，小於或等於它的數全放到它的左邊
3、再對左右區間重複第二步，直到各區間只有一個數

    /**
     * 快速排序
     * @param array
     * @param left
     * @param right
     */
    public static void quickSort(int[] array,int left,int right){
        if(left>right){
            return;
        }
        int i = left,j = right,temp = array[left];
        while (i!=j){
            while(array[j]>=temp&&i<j){
                j--;
            }
            while (array[i]<=temp&&i<j){
                i++;
            }
            if(i<j){
                swap(array,i,j);
            }
        }
        array[left] = array[i];
        array[i] = temp;
        quickSort(array,left,i-1);
        quickSort(array,i+1,right);
    }