本系列最後一篇，綜合分析下前面介紹的八種排序演算法的效率，以及各自的適用情況。
下面先看看八種排序演算法的時間複雜度表格：

圖中八種排序被分成了兩組，一組時間複雜度為O(n^2)，另一組相對高效些。
下面先對第一組O(n^2)的四種排序演算法進行對比，分別取陣列長度為100,1000,10000,100000四個數量級，各個元素在0-10000000之間隨機獲取。下面看下結果的分析。

從上表可以看出，以上四種演算法效率最高的絕對是希爾排序，其次是直接插入排序，再就是直接選擇排序，最後才是氣泡排序。事實證明氣泡排序真的不適合實際應用，實際使用中最優先選擇希爾排序，但是如果要求穩定性的話就選擇直接插入排序，但是效率差太多了。
下面主要對另外四個排序演算法進行對比，不過通過上面的結果，所以在這裡把希爾排序也加進來一起比較。由於基數排序對陣列最大位數敏感，所以這裡會分別對最大值為3位、4位、5位、6位、7位五種情況分別對應長度為10000,100000,1000000,10000000四種情況進行比較，長度太小體現不出O(nlgn)的優勢。

上表是MaxValue=1000時的結果，從表中可以看出當長度為10000時快速排序和歸併排序效果最好，基數排序效果最差，但是當長度達到10W和100W基數排序效果最好，不過歸併排序效率就比快速排序高很多了，同時快速排序當排序陣列長度達到100W時效果變得很差，遠遠落後其他四個排序演算法。所以當待排序陣列最大值為1000時，陣列長度為10000時使用快速和歸併，當長度為1000W以內使用基數排序，或者歸併排序。

以上是MaxValue=10000時的結果，從表中可以看出基數排序的效果最好，其次是歸併排序，然後快速排序。所以當待排序陣列最大值為10000時使用基數排序還是很不錯的，雖然長度在10000時效果不如歸併排序。當然歸併排序也是個不錯的選擇。

以上是MaxValue=100000時的結果，從表中可以看出結果同MaxValue=10000時的結果差不多。

以上是MaxValue=1000000時的結果，結果還是一樣，基數排序效果最好。

以上是MaxValue=10000000時的結果，基數排序的效率已經沒有歸併排序好了，應該由於歸併的次數增加了。
這裡有個地方很奇怪，可以從上面MaxValue=1000時的表中可以看到當長度=100W時，快速排序的時間超過其他四個排序一個數量級，但是當MaxValue=10000，甚至更大之後快速排序的時間都和其它排序是一個數據量，而且MaxValue=1000時耗時大於MaxValue=10000以上。具體原因未知，大家可以自己測試，也許重複元素太多會影響快速排序的效率？
綜合以上所有測試結果，總結各個排序演算法的適用場景。
直接插入排序：直接用希爾排序替代就好，除非待排序陣列本身就是部分有序
希爾排序： 效果最好，秒殺所有O(n^2)的排序演算法，所在在資料量較小的場景下，如100000個元素以下都可考慮希爾排序
直接選擇排序： 直接用希爾排序替代，或者用堆排序替代
氣泡排序： 強烈推薦不使用此排序演算法
堆排序： 優於希爾排序，推薦替代希爾排序，但是如果待排序陣列是部分有序的那麼希爾優於堆排序
快速排序： 陣列長度100W以下效率最高，100W以上可以用歸併排序替代
歸併排序： 不考慮基數排序的話，陣列長度100W以上效率最高，100W以下可以用快速排序替代
基數排序： 適用場景要求較高，元素必須是整數，整數時長度10W以上，最大值100W以下效率較好，但是基數排序比其他排序好在可以適用字串，或者其他需要根據多個條件進行排序的場景，例如日期，先排序日，再排序月，最後排序年 ，其它排序演算法可是做不了的。
下面附上測試程式碼：

package com.vicky.sort;

import java.util.Random;
import java.util.Scanner;

import org.junit.Test;

public class SortComparison2 {

    /**
     * 比較全部排序演算法
     */
    @Test
    public void testAll() {
        Scanner scan = new Scanner(System.in);
        int num = -1;
        int maxValue = -1;
        while (true) {
            // 從命令列輸入元素數量，以及最大值，格式：10,1000，輸入quit結束
            String input = scan.next();
            if ("quit".equals(input)) {
                System.exit(1);
            }
            String[] strs = input.split(",");
            num = Integer.parseInt(strs[0]);
            maxValue = Integer.parseInt(strs[1]);
            System.out.println("Sort Data Num = " + num + ", MaxValue = " + maxValue);

            Random ran = new Random();
            Integer[] data = new Integer[num];
            Integer[] data1 = new Integer[data.length];
            Integer[] data2 = new Integer[data.length];
            Integer[] data3 = new Integer[data.length];
            Integer[] data4 = new Integer[data.length];
            Integer[] data5 = new Integer[data.length];
            Integer[] data6 = new Integer[data.length];
            Integer[] data7 = new Integer[data.length];
            Integer[] data8 = new Integer[data.length];
            for (int i = 0; i < data.length; i++) {
                data[i] = ran.nextInt(maxValue);
                data1[i] = data[i];
                data2[i] = data[i];
                data3[i] = data[i];
                data4[i] = data[i];
                data5[i] = data[i];
                data6[i] = data[i];
                data7[i] = data[i];
                data8[i] = data[i];
            }
            // 插入排序
            long insertTimes = testStraightInsertionSort(data1);
            long shellTimes = testShellSort(data2);
            // 選擇排序
            long selectTimes = testStraightSelectionSort(data3);
            long heapTimes = testHeapSort(data4);
            // 交換排序
            long bubbleTimes = testBubbleSort(data5);
            long quickTimes = testQuickSort(data6);
            // 歸併排序
            long mergeTimes = testMergeSort(data7);
            // 基數排序
            long radixTimes = testRadixSort(data8);

            System.out.println("method       \ttime(ms)");
            System.out.println("InsertionSort\t" + insertTimes);
            System.out.println("ShellSort    \t" + shellTimes);
            System.out.println("SelectionSort\t" + selectTimes);
            System.out.println("HeapSort     \t" + heapTimes);
            System.out.println("BubbleSort   \t" + bubbleTimes);
            System.out.println("QuickSort    \t" + quickTimes);
            System.out.println("MergeSort    \t" + mergeTimes);
            System.out.println("RadixSort    \t" + radixTimes);
        }
    }

    /**
     *測試時間複雜度為O(n^2)的排序
     */
    @Test
    public void testBase() {
        Scanner scan = new Scanner(System.in);
        int num = -1;
        int maxValue = -1;
        while (true) {
            // 從命令列輸入元素數量，以及最大值，格式：10,1000，輸入quit結束
            String input = scan.next();
            if ("quit".equals(input)) {
                System.exit(1);
            }
            String[] strs = input.split(",");
            num = Integer.parseInt(strs[0]);
            maxValue = Integer.parseInt(strs[1]);
            System.out.println("Sort Data Num = " + num + ", MaxValue = " + maxValue);

            Random ran = new Random();
            Integer[] data = new Integer[num];
            Integer[] data1 = new Integer[data.length];
            Integer[] data2 = new Integer[data.length];
            Integer[] data3 = new Integer[data.length];
            Integer[] data4 = new Integer[data.length];
            for (int i = 0; i < data.length; i++) {
                data[i] = ran.nextInt(maxValue);
                data1[i] = data[i];
                data2[i] = data[i];
                data3[i] = data[i];
                data4[i] = data[i];
            }
            // 插入排序
            long insertTimes = testStraightInsertionSort(data1);
            long shellTimes = testShellSort(data2);
            // 選擇排序
            long selectTimes = testStraightSelectionSort(data3);
            // 交換排序
            long bubbleTimes = testBubbleSort(data4);

            System.out.println("method       \ttime(ms)");
            System.out.println("InsertionSort\t" + insertTimes);
            System.out.println("ShellSort    \t" + shellTimes);
            System.out.println("SelectionSort\t" + selectTimes);
            System.out.println("BubbleSort   \t" + bubbleTimes);
        }
    }

    /**
     * 比較O(nlgn)左右的排序演算法
     * 
     * 這裡把希爾加上是因為雖然希爾時間複雜度是O(n^2)但是從實際結果來看其效率還是較高的，所以拿來跟O(nlgn)一起對比
     */
    @Test
    public void testGood() {
        Scanner scan = new Scanner(System.in);
        int num = -1;
        int maxValue = -1;
        while (true) {
            // 從命令列輸入元素數量，以及最大值，格式：10,1000，輸入quit結束
            String input = scan.next();
            if ("quit".equals(input)) {
                System.exit(1);
            }
            String[] strs = input.split(",");
            num = Integer.parseInt(strs[0]);
            maxValue = Integer.parseInt(strs[1]);
            System.out.println("Sort Data Num = " + num + ", MaxValue = " + maxValue);

            Random ran = new Random();
            Integer[] data = new Integer[num];
            Integer[] data1 = new Integer[data.length];
            Integer[] data2 = new Integer[data.length];
            Integer[] data3 = new Integer[data.length];
            Integer[] data4 = new Integer[data.length];
            Integer[] data5 = new Integer[data.length];
            for (int i = 0; i < data.length; i++) {
                data[i] = ran.nextInt(maxValue);
                data1[i] = data[i];
                data2[i] = data[i];
                data3[i] = data[i];
                data4[i] = data[i];
                data5[i] = data[i];
            }
            // 插入排序
            long shellTimes = testShellSort(data1);
            // 選擇排序
            long heapTimes = testHeapSort(data2);
            // 交換排序
            long quickTimes = testQuickSort(data3);
            // 歸併排序
            long mergeTimes = testMergeSort(data4);
            // 基數排序
            long radixTimes = testRadixSort(data5);

            System.out.println("method       \ttime(ms)");
            System.out.println("ShellSort    \t" + shellTimes);
            System.out.println("HeapSort     \t" + heapTimes);
            System.out.println("QuickSort    \t" + quickTimes);
            System.out.println("MergeSort    \t" + mergeTimes);
            System.out.println("RadixSort    \t" + radixTimes);
        }
    }

    public static <T extends Comparable<T>> long testStraightInsertionSort(T[] data) {
        long start = System.nanoTime();
        StraightInsertionSort.sort(data);
        return (System.nanoTime() - start) / 1000;
    }

    public static <T extends Comparable<T>> long testShellSort(T[] data) {
        long start = System.nanoTime();
        ShellSort.sort(data);
        return (System.nanoTime() - start) / 1000;
    }

    public static <T extends Comparable<T>> long testStraightSelectionSort(T[] data) {
        long start = System.nanoTime();
        StraightSelectionSort.sort(data);
        return (System.nanoTime() - start) / 1000;
    }

    public static <T extends Comparable<T>> long testHeapSort(T[] data) {
        long start = System.nanoTime();
        HeapSort.sort(data);
        return (System.nanoTime() - start) / 1000;
    }

    public static <T extends Comparable<T>> long testBubbleSort(T[] data) {
        long start = System.nanoTime();
        BubbleSort.sort(data);
        return (System.nanoTime() - start) / 1000;
    }

    public static <T extends Comparable<T>> long testQuickSort(T[] data) {
        long start = System.nanoTime();
        QuickSort.sort(data);
        return (System.nanoTime() - start) / 1000;
    }

    public static <T extends Comparable<T>> long testMergeSort(T[] data) {
        long start = System.nanoTime();
        MergeSort.sort(data);
        return (System.nanoTime() - start) / 1000;
    }

    public static long testRadixSort(Integer[] data) {
        long start = System.nanoTime();
        RadixSort.sort(data);
        return (System.nanoTime() - start) / 1000;
    }
}

執行時需要指定JVM執行引數：-Xms1024m -Xmx1024m -Xss2048k。
以上測試可能會有偏差，