常見的排序算法——常見的10種排序

算法分類

常見算法可以分為兩大類：

　　非線性時間比較類排序：通過比較來決定元素間的相對次序，由於其時間復雜度不能突破O(nlogn)，因此稱為非線性時間比較類排序。

　　線性時間非比較類排序：不通過比較來決定元素間的相對次序，它可以突破基於比較排序的時間下界，以線性時間運行，因此稱為線性時間非比較類排序。

 

算法復雜度：

 1、冒泡排序
思路：外層循環從1到n-1，內循環從當前外層的元素的下一個位置開始，依次和外層的元素比較，出現逆序就交換，通過與相鄰元素的比較和交換來把小的數交換到最前面。

for(int i=0;i<arr.length-1;i++){//外層循環控制排序趟數
　　　　　　for(int j=0;j<arr.length-1-i;j++){//內層循環控制每一趟排序多少次
　　　　　　　　if(arr[j]>arr[j+1]){
　　　　　　　　　　int temp=arr[j];
　　　　　　　　　　arr[j]=arr[j+1];
　　　　　　　　　　arr[j+1]=temp;
　　　　　　　　}
　　　　　　}
　　　　} 

2、選擇排序
思路：冒泡排序是通過相鄰的比較和交換，每次找個最小值。選擇排序是：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再從剩余未排序元素中繼續尋找最小（大）元素，然后放到已排序序列的末尾。以此類推，直到所有元素均排序完畢。

 private static void sort(int[] array) {
        int n = array.length;
        for (int i = 0; i < n-1; i++) {
            int min = i;
            for (int j = i+1; j < n; j++) {
                if (array[j] < array[min]){//尋找最小數
                    min = j;                      //將最小數的索引賦值
                 }  
            }
            int temp = array[i];
            array[i] = array[min];
            array[min] = temp;

        }
    }
                       

3、插入排序
思路：通過構建有序序列，對於未排序數據，在已排序序列中從后向前掃描，找到相應位置並插入。可以理解為玩撲克牌時的理牌；

private static void sort(int[] array) {
        int n = array.length;
    /**
    *從第二位數字開始，每一個數字都試圖跟它的前一個比較並交換，並重復；直到前一個數字不存在或者比它小或相等時停下來
    **/
        for (int i = 1; i < n; i++) {//從第二個數開始
            int key = array[i];
            int j = i -1;
            while (j >= 0 && array[j]>key) {
                array[j + 1] = array[j];     //交換
                j--;                                //下標向前移動
            }
            array[j+1] = key;
        }
    }

 

4、希爾排序
思路：希爾排序是插入排序的一種高效率的實現，也叫縮小增量排序。先將整個待排記錄序列分割成為若干子序列分別進行直接插入排序，待整個序列中的記錄基本有序時再對全體記錄進行一次直接插入排序。
問題：增量的序列取法？
　　關於取法，沒有統一標准，但最后一步必須是1；因為不同的取法涉及時間復雜度不一樣，具體了解可以參考《數據結構與算法分析》；一般以length/2為算法。（再此以gap=gap*3+1為公式）

private static void sort(int[] array) {
        int n = array.length;
        int h = 1;
        while (h<n/3) { //動態定義間隔序列
              h = 3*h +1;
                 }
         while (h >= 1) {
            for (int i = h; i < n; i++) {
                for (int j = i; j >= h && (array[j] < array[j - h]); j -= h) {
                    int temp = array[j];
                    array[j] = array[j - h];
                    array[j-h]= temp;
                }
            }
            h /=3;
        }
    }

5、歸並排序
思路：將已有序的子序列合並，得到完全有序的序列；即先使每個子序列有序，再使子序列段間有序。若將兩個有序表合並成一個有序表，稱為2-路歸並。它使用了遞歸分治的思想；相當於：左半邊用盡，則取右半邊元素；右半邊用盡，則取左半邊元素；右半邊的當前元素小於左半邊的當前元素，則取右半邊元素；右半邊的當前元素大於左半邊的當前元素，則取左半邊的元素。
　　自頂向下：

 private static void mergeSort(int[] array) {
        int[] aux = new int[array.length];
        sort(array, aux, 0, array.length - 1);
    }

    private static void sort(int[] array, int[] aux, int lo, int hi) {
        if (hi<=lo) return;
        int mid = lo + (hi - lo)/2;
        sort(array, aux, lo, mid);
        sort(array, aux, mid + 1, hi);
        merge(array, aux, lo, mid, hi);
    }

    private static void merge(int[] array, int[] aux, int lo, int mid, int hi) {
        System.arraycopy(array,0,aux,0,array.length);
        int i = lo, j = mid + 1;
        for (int k = lo; k <= hi; k++) {
            if (i>mid) array[k] = aux[j++];
            else if (j > hi) array[k] = aux[i++];
            else if (aux[j]<aux[i]) array[k] = aux[j++];
            else array[k] = aux[i++];
        }
    }

　　自底向上：

public static void sort(int[] array) {
        int N = a.length;
        int[] aux = new int[N];
        for (int n = 1; n < N; n = n+n) {
            for (int i = 0; i < N-n; i += n+n) {
                int lo = i;
                int m  = i+n-1;
                int hi = Math.min(i+n+n-1, N-1);
                merge(array, aux, lo, m, hi);
            }
        }
    }

    private static void merge(int[] array, int[] aux, int lo, int mid, int hi) {
        for (int k = lo; k <= hi; k++) {
            aux[k] = array[k];
        }
        // merge back to a[]
        int i = lo, j = mid+1;
        for (int k = lo; k <= hi; k++) {
            if      (i > mid)              array[k] = aux[j++];  // this copying is unneccessary
            else if (j > hi)               array[k] = aux[i++];
            else if (aux[j]<aux[i]) array[k] = aux[j++];
            else                           array[k] = aux[i++];
        }
    }

缺點：因為是Out-place sort，因此相比快排，需要很多額外的空間。

為什么歸並排序比快速排序慢？

　　答：雖然漸近復雜度一樣，但是歸並排序的系數比快排大。

對於歸並排序有什么改進？

　　答：就是在數組長度為k時，用插入排序，因為插入排序適合對小數組排序。在算法導論思考題2-1中介紹了。復雜度為O(nk+nlg(n/k)) ，當k=O(lgn)時，復雜度為O(nlgn)

例子：

    private static int mark = 0; 
      /**
       * 歸並排序
       */
      private static int[] sort(int[] array, int low, int high) {
        int mid = (low + high) / 2;
        if (low < high) {
          mark++;
          System.out.println("正在進行第" + mark + "次分隔，得到");
          System.out.println("[" + low + "-" + mid + "] [" + (mid + 1) + "-" + high + "]");
          // 左邊數組
          sort(array, low, mid);
          // 右邊數組
          sort(array, mid + 1, high);
          // 左右歸並
          merge(array, low, mid, high);
        }
        return array;
      }
     
      /**
       * 對數組進行歸並
       * 
       * @param array
       * @param low
       * @param mid
       * @param high
       */
      private static void merge(int[] array, int low, int mid, int high) {
        System.out.println("合並:[" + low + "-" + mid + "] 和 [" + (mid + 1) + "-" + high + "]");
        int[] temp = new int[high - low + 1];
        int i = low;// 左指針
        int j = mid + 1;// 右指針
        int k = 0;
        // 把較小的數先移到新數組中
        while (i <= mid && j <= high) {
          if (array[i] < array[j]) {
            temp[k++] = array[i++];
          } else {
            temp[k++] = array[j++];
          }
        }
        // 兩個數組之一可能存在剩余的元素
        // 把左邊剩余的數移入數組
        while (i <= mid) {
          temp[k++] = array[i++];
        }
        // 把右邊邊剩余的數移入數組
        while (j <= high) {
          temp[k++] = array[j++];
        }
        // 把新數組中的數覆蓋array數組
        for (int m = 0; m < temp.length; m++) {
          array[m + low] = temp[m];
        }
      }
     
      /**
       * 歸並排序
       */
      public static int[] sort(int[] array) {
        return sort(array, 0, array.length - 1);
      }
     
      public static void main(String[] args) {
        int[] array = { 3, 5, 2, 6, 2 };
        int[] sorted = sort(array);
        System.out.println("最終結果");
        for (int i : sorted) {
          System.out.print(i + " ");
        }
      }

 

6、快速排序
思路：通過一趟排序將待排記錄分隔成獨立的兩部分，其中一部分記錄的關鍵字均比另一部分的關鍵字小，則可分別對這兩部分記錄繼續進行排序，以達到整個序列有序。

private static void sort(int[] array) {
        shuffle(array);
        sort(array, 0, array.length - 1);
    }
    private static void sort(int[] array, int lo, int hi) {
       if(hi<=lo+M) {
        Insert.sort(a,lo,hi);
        return;
        }
        int lt = lo, gt = hi;
        int v = array[lo];
        int i = lo;
        while (i <= gt) {
            if      (array[i]<v) exch(array, lt++, i++);
            else if (array[i]>v) exch(array, i, gt--);
            else              i++;
        }
        // a[lo..lt-1] < v = a[lt..gt] < a[gt+1..hi].
        sort(array, lo, lt-1);
        sort(array, gt+1, hi);
    }

    private static void exch(int[] a, int i, int j) {
        int swap = a[i];
        a[i] = a[j];
        a[j] = swap;
    }

    /**
     *打亂數組
     */
    private static void shuffle(int[] array) {
        Random random = new Random(System.currentTimeMillis());
        if (array == null) throw new NullPointerException("argument array is null");
        int n = array.length;
        for (int i = 0; i < n; i++) {
            int r = i + random.nextInt(n-i);     // between i and n-1
            int temp = array[i];
            array[i] = array[r];
            array[r] = temp;
        }
    }
    
代碼例子：

package test;

public class s {
      public static void main(String[] args) {
            int[] arr = { 5,2,4,9,7 };
            sort(arr, 0, arr.length - 1);
        }
        public static void sort(int arr[], int low, int high) {
            int l = low;
            int h = high;
            int k = arr[low];
            while (l < h) {
                // 從后往前比較
                while (l < h && arr[h] >= k ){ // 如果沒有比關鍵值小的，比較下一個，直到有比關鍵值小的交換位置，然后又從前往后比較
                    h--;// h=6
                }
                if (l < h) {
                    int temp = arr[h];
                    arr[h] = arr[l];
                    arr[l] = temp;
                    //進行過一次替換后，沒必要將替換后的兩值再次比較，所以i++直接下一位與k對比
                    l++;
                }
                // 從前往后比較
                while (l < h && arr[l] <= k) { // 如果沒有比關鍵值大的，比較下一個，直到有比關鍵值大的交換位置
                    l++;
                }
                if (l < h) {
                    int temp = arr[h];
                    arr[h] = arr[l];
                    arr[l] = temp;
                    h--;
                }
                // 此時第一次循環比較結束，關鍵值的位置已經確定了。左邊的值都比關鍵值小，右邊的值都比關鍵值大，但是兩邊的順序還有可能是不一樣的，進行下面的遞歸調用
            }
            print(arr);
            System.out.print("l=" + (l + 1) + "h=" + (h + 1) + "k=" + k + "\n");
            // 遞歸
            if (l > low)//先判斷l>low再次經行左邊排序
                sort(arr, low, l - 1);// 左邊序列。第一個索引位置到關鍵值索引-1
            if (h < high)//左邊依次排序執行完遞歸后，彈棧進行右邊排序
                sort(arr, l + 1, high);// 右邊序列。從關鍵值索引+1到最后一個
        }
        // 打印數組的方法
        private static void print(int[] arr) {
            System.out.print("[");
            for (int i = 0; i < arr.length; i++) {
                if (i != (arr.length - 1)) {
                    System.out.print(arr[i] + ",");
                } else {
                    System.out.print(arr[i] + "]");
                    System.out.println();
                }
            }
        }
}

 

7、堆排序
思路：堆積是一個近似完全二叉樹的結構，並同時滿足堆積的性質：即子結點的鍵值或索引總是小於（或者大於）它的父節點。

 public static void sort(int[] a){
        int N = a.length;
        int[] keys = new int[N+1];
        //注意，堆的數據結構是從1開始的，0不用
        for (int i = 1; i < keys.length; i++) {
            keys[i] = a[i-1];
        }
//      //構造堆,使得堆是有序的
        for(int k = N/2;k>=1;k--) sink(keys,k,N);
        //排序，相當於毀掉堆
        while(N>1){
            exch(keys,1,N--);
            sink(keys,1,N);
        }
        //重新寫回數組
        for (int i = 0; i < a.length; i++) {
            a[i] = keys[i+1];
        }
    }

    private static void sink(int[] a, int k, int N) {
        // TODO Auto-generated method stub
        while(2*k<=N){
            int j = 2*k;
            if (j < N && less(a[j], a[j+1])) j++;
            if (less(a[j], a[k])) break;
            exch(a, k, j);
            k = j;
        }
    }

    private static boolean less(int k, int j) {
        // TODO Auto-generated method stub
        return k < j;
    }

    private static void exch(int[] a, int i, int n) {
        // TODO Auto-generated method stub
        int temp = a[i];
        a[i] = a[n];
        a[n] = temp;
    }

 

代碼例子：

package test;

public class dui {
    /** 
       * 調整為小頂堆（排序后結果為從大到小）
       * 
       * @param array是待調整的堆數組 
       * @param s是待調整的數組元素的位置
       * @param length是數組的長度
       * 
       */
      public static void heapAdjustS(int[] array, int s, int length) {
        int tmp = array[s];
        int child = 2 * s + 1;// 左孩子結點的位置
        System.out.println("待調整結點為：array[" + s + "] = " + tmp);
        while (child < length) {
          // child + 1 是當前調整結點的右孩子
          // 如果有右孩子且小於左孩子，使用右孩子與結點進行比較，否則使用左孩子
          if (child + 1 < length && array[child] > array[child + 1]) {
            child++;
          }
          System.out.println("將與子孩子 array[" + child + "] = " + array[child] + " 進行比較");
          // 如果較小的子孩子比此結點小
          if (array[s] > array[child]) {
            System.out.println("子孩子比其小，交換位置");
            array[s] = array[child];// 把較小的子孩子向上移動，替換當前待調整結點
            s = child;// 待調整結點移動到較小子孩子原來的位置
            array[child] = tmp;
            child = 2 * s + 1;// 繼續判斷待調整結點是否需要繼續調整
             
            if (child >= length) {
              System.out.println("沒有子孩子了，調整結束");
            } else {
              System.out.println("繼續與新的子孩子進行比較");
            }
            // continue;
          } else {
            System.out.println("子孩子均比其大，調整結束");
            break;// 當前待調整結點小於它的左右孩子，不需調整，直接退出
          }
        }
      }
       
      /** 
       * 調整為大頂堆（排序后結果為從小到大）
       * 
       * @param array是待調整的堆數組 
       * @param s是待調整的數組元素的位置
       * @param length是數組的長度
       * 
       */
      public static void heapAdjustB(int[] array, int s, int length) {
        int tmp = array[s];
        int child = 2 * s + 1;// 左孩子結點的位置
        System.out.println("待調整結點為：array[" + s + "] = " + tmp);
        while (child < length) {
          // child + 1 是當前調整結點的右孩子
          // 如果有右孩子且大於左孩子，使用右孩子與結點進行比較，否則使用左孩子
          if (child + 1 < length && array[child] < array[child + 1]) {
            child++;
          }
          System.out.println("將與子孩子 array[" + child + "] = " + array[child] + " 進行比較");
          // 如果較大的子孩子比此結點大
          if (array[s] < array[child]) {
            System.out.println("子孩子比其大，交換位置");
            array[s] = array[child];// 把較大的子孩子向上移動，替換當前待調整結點
            s = child;// 待調整結點移動到較大子孩子原來的位置
            array[child] = tmp;
            child = 2 * s + 1;// 繼續判斷待調整結點是否需要繼續調整
             
            if (child >= length) {
              System.out.println("沒有子孩子了，調整結束");
            } else {
              System.out.println("繼續與新的子孩子進行比較");
            }
            // continue;
          } else {
            System.out.println("子孩子均比其小，調整結束");
            break;// 當前待調整結點大於它的左右孩子，不需調整，直接退出
          }
        }
      }
        
      /**
       * 堆排序算法
       * 
       * @param array
       * @param inverse true 為倒序排列，false 為正序排列
       */
      public static void heapSort(int[] array, boolean inverse) {
        // 初始堆
        // 最后一個有孩子的結點位置 i = (length - 1) / 2, 以此向上調整各結點使其符合堆
        System.out.println("初始堆開始");
        for (int i = (array.length - 1) / 2; i >= 0; i--) {
          if (inverse) {
            heapAdjustS(array, i, array.length);
          } else {
            heapAdjustB(array, i, array.length);
          }
        }
        System.out.println("初始堆結束");
        for (int i = array.length - 1; i > 0; i--) {
          // 交換堆頂元素H[0]和堆中最后一個元素
          int tmp = array[i];
          array[i] = array[0];
          array[0] = tmp;
          // 每次交換堆頂元素和堆中最后一個元素之后，都要對堆進行調整
          if (inverse) {
            heapAdjustS(array, 0, i);
          } else {
            heapAdjustB(array, 0, i);
          }
        }
      }
     
      public static void main(String[] args) {
        int[] array = { 49, 38, 65, 97, 76, 13, 27, 49 };
        heapSort(array, false);
        for (int i : array) {
          System.out.print(i + " ");
        }
      }

}

 

8、計數排序
思路：將輸入的數據值轉化為鍵存儲在額外開辟的數組空間中。 作為一種線性時間復雜度的排序，計數排序要求輸入的數據必須是有確定范圍的整數。

　　找出待排序的數組中最大和最小的元素；
　　統計數組中每個值為i的元素出現的次數，存入數組C的第i項；
　　對所有的計數累加（從C中的第一個元素開始，每一項和前一項相加）；
　　反向填充目標數組：將每個元素i放在新數組的第C(i)項，每放一個元素就將C(i)減去1。

 /**
     * 輸入數組的元素都是介於0..k之間的
     * @param data 待排序數組
     * @param k 最大元素
     * @return 排序結果
     */
    public static int[] sort(int[] data, int k) {
        // 存放臨時數據的數組tmp，初始元素都是0；k為數組中最大元素
        int[] tmp = new int[k + 1];

        // 計算數組中每個元素i出現的次數，存入數組tmp中的第i項，即原數組中的元素值為tmp數組中的下標
        for (int i = 0; i <= data.length - 1; i++) {
            tmp[data[i]]++;
        }
        // 計算數組中小於等於每個元素的個數,即從tmp中的第一個元素開始，每一項和前一項相加
        for (int j = 1; j <= k; j++) {
            tmp[j] = tmp[j] + tmp[j - 1];
        }
        // result數組用來來存放排序結果
        int[] result = new int[data.length];
        for (int i = data.length - 1; i >= 0; i--) {
            result[tmp[data[i]] - 1] = data[i];
            tmp[data[i]]--;
        }
        return result;
    }

 

代碼例子：

package test;

public class jishu {
    public static int[] countingSort(int[] theArray) {
        int[] lastArray = new int[theArray.length];
        for(int i = 0; i < theArray.length; i++) {
            int count = 0;
            for(int j = 0; j < theArray.length; j++) {
                if(theArray[i] > theArray[j]) {
                    count++;
                }
            }
            lastArray[count] = theArray[i];
        }
        return lastArray;
    }
    public static void main(String[] args) {
        int []theArray = {6, 4, 5, 1, 8, 7, 2, 3};
        System.out.print("之前的排序：");
        for(int i = 0; i < theArray.length; i++) {
            System.out.print(theArray[i] + " ");
        }
        
        int []resultArray = countingSort(theArray);
        
        System.out.print("計數排序：");
        for(int i = 0; i < resultArray.length; i++) {
            System.out.print(resultArray[i] + " ");
        }
    }

}

 

9、桶排序
思路：桶排序是計數排序的升級版。它利用了函數的映射關系，高效與否的關鍵就在於這個映射函數的確定。桶排序 (Bucket sort)的工作的原理：假設輸入數據服從均勻分布，將數據分到有限數量的桶里，每個桶再分別排序（有可能再使用別的排序算法或是以遞歸方式繼續使用桶排序進行排）。

　　設置一個定量的數組當作空桶；
　　遍歷輸入數據，並且把數據一個一個放到對應的桶里去；
　　對每個不是空的桶進行排序；
　　從不是空的桶里把排好序的數據拼接起來。

public static void bucketSort(double array[]) {
        int length = array.length;
        ArrayList arrList[] = new ArrayList[length];
        for (int i = 0; i < length; i++) {
            //0.7到0.79放在第8個桶里,編號7；第一個桶放0到0.09
            int temp = (int) Math.floor(10 * array[i]);
            if (null == arrList[temp])
                arrList[temp] = new ArrayList();
            arrList[temp].add(array[i]);
        }
        // 對每個桶中的數進行插入排序
        for (int i = 0; i < length; i++) {
            if (null != arrList[i]) {
                Collections.sort(arrList[i]);
            }
        }
        int count = 0;
        for (int i = 0; i < length; i++) {
            if (null != arrList[i]) {
                Iterator iter = arrList[i].iterator();
                while (iter.hasNext()) {
                    Double d = (Double) iter.next();
                    array[count] = d;
                    count++;
                }
            }
        }
    }

 

代碼例子：

package test;

public class tong {
    private int[] buckets;
      private int[] array;
       
      public tong(int range,int[] array){
        this.buckets = new int[range];
        this.array = array;
      }
       
      /*排序*/
      public void sort(){
        if(array!=null && array.length>1){
          for(int i=0;i<array.length;i++){
            buckets[array[i]]++;
          }
        }
      }
       
      /*排序輸出*/
      public void sortOut(){
        //倒序輸出數據
        for (int i=buckets.length-1; i>=0; i--){
          for(int j=0;j<buckets[i];j++){
            System.out.print(i+"\t");
          }      
        }
      }

      
      public static void main(String[] args) {
            testBucketsSort();
          }
           
          private static void testBucketsSort(){
            int[] array = {5,7,3,5,4,8,6,4,1,2};
            tong bs = new tong(10, array);
            bs.sort();
            bs.sortOut();//輸出打印排序
          }

}

 

10、基數排序
思路：基數排序是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次類推，直到最高位。有時候有些屬性是有優先級順序的，先按低優先級排序，再按高優先級排序。最后的次序就是高優先級高的在前，高優先級相同的低優先級高的在前。

　　取得數組中的最大數，並取得位數；
　　arr為原始數組，從最低位開始取每個位組成radix數組；
　　對radix進行計數排序（利用計數排序適用於小范圍數的特點）；

private static void radixSort(int[] array,int radix, int distance) {
        int length = array.length;
        int[] temp = new int[length];
        int[] count = new int[radix];
        int divide = 1;

        for (int i = 0; i < distance; i++) {

            System.arraycopy(array, 0,temp, 0, length);
            Arrays.fill(count, 0);

            for (int j = 0; j < length; j++) {
                int tempKey = (temp[j]/divide)%radix;
                count[tempKey]++;
            }

            for (int j = 1; j < radix; j++) {
                count [j] = count[j] + count[j-1];
            }
            for (int j = length - 1; j >= 0; j--) {
                int tempKey = (temp[j]/divide)%radix;
                count[tempKey]--;
                array[count[tempKey]] = temp[j];
            }
            divide = divide * radix;
        }
    }

 

代碼例子：

package test;

    /**
     * 基數排序
     * 平均O(d(n+r)),最好O(d(n+r)),最壞O(d(n+r));空間復雜度O(n+r);穩定;較復雜
     * d為位數,r為分配后鏈表的個數
     * 
     *
     */
    public class ji_shu {
        //pos=1表示個位，pos=2表示十位
        public static int getNumInPos(int num, int pos) {
            int tmp = 1;
            for (int i = 0; i < pos - 1; i++) {
                tmp *= 10;
            }
            return (num / tmp) % 10;
        }
        //求得最大位數d
        public static int getMaxWeishu(int[] a) {
            int max = a[0];
            for (int i = 0; i < a.length; i++) {
                if (a[i] > max)
                        max = a[i];
            }
            int tmp = 1, d = 1;
            while (true) {
                tmp *= 10;
                if (max / tmp != 0) {
                    d++;
                } else
                        break;
            }
            return d;
        }
        public static void radixSort(int[] a, int d) {
            int[][] array = new int[10][a.length + 1];
            for (int i = 0; i < 10; i++) {
                array[i][0] = 0;
                // array[i][0]記錄第i行數據的個數
            }
            for (int pos = 1; pos <= d; pos++) {
                for (int i = 0; i < a.length; i++) {
                    // 分配過程
                    int row = getNumInPos(a[i], pos);
                    int col = ++array[row][0];
                    array[row][col] = a[i];
                }
                for (int row = 0, i = 0; row < 10; row++) {
                    // 收集過程
                    for (int col = 1; col <= array[row][0]; col++) {
                        a[i++] = array[row][col];
                    }
                    array[row][0] = 0;
                    // 復位，下一個pos時還需使用
                }
            }
        }
        public static void main(String[] args) {
            int[] a = { 49, 38, 65, 197, 76, 213, 27, 50 };
            radixSort(a, getMaxWeishu(a));
            for (int i : a)
                  System.out.print(i + " ");
        }
    }

 

小結
　　排序算法要么簡單有效，要么是利用簡單排序的特點加以改進，要么是以空間換取時間在特定情況下的高效排序。但是這些排序方法都不是固定不變的，需要結合具體的需求和場景來選擇甚至組合使用。才能達到高效穩定的目的。沒有最好的排序，只有最適合的排序。
　　下面就總結一下排序算法的各自的使用場景和適用場合。

1. 從平均時間來看，快速排序是效率最高的，但快速排序在最壞情況下的時間性能不如堆排序和歸並排序。而后者相比較的結果是，在n較大時歸並排序使用時間較少，但使用輔助空間較多。

2. 上面說的簡單排序包括除希爾排序之外的所有冒泡排序、插入排序、簡單選擇排序。其中直接插入排序最簡單，但序列基本有序或者n較小時，直接插入排序是好的方法，因此常將它和其他的排序方法，如快速排序、歸並排序等結合在一起使用。

3. 基數排序的時間復雜度也可以寫成O(d*n)。因此它最使用於n值很大而關鍵字較小的的序列。若關鍵字也很大，而序列中大多數記錄的最高關鍵字均不同，則亦可先按最高關鍵字不同，將序列分成若干小的子序列，而后進行直接插入排序。

4. 從方法的穩定性來比較，基數排序是穩定的內排方法，所有時間復雜度為O(n^2)的簡單排序也是穩定的。但是快速排序、堆排序、希爾排序等時間性能較好的排序方法都是不穩定的。穩定性需要根據具體需求選擇。

5. 上面的算法實現大多數是使用線性存儲結構，像插入排序這種算法用鏈表實現更好，省去了移動元素的時間。具體的存儲結構在具體的實現版本中也是不同的。