常见排序算法效率比较

本文对冒泡排序、选择排序、插入排序和快速排序进行实际耗时比较。

其实大家都知道，这几种排序算法中，无疑快速排序是最快的（要不然叫啥快速排序呢）。另外，Java中的Arrays工具类中的排序选用的就是快速排序，这不是没有原因的。

那么快速排序究竟有多快，比其他几种排序算法又快多少呢？本文通过实际代码对这个问题进行简单探讨。

首先，代码实现几种排序算法，原理就不讲了，不熟悉的自行补课。

//冒泡  
private static void bubbleSort(int[] array) {  
    int temp;  
    for (int i = 0; i < array.length - 1; i++) {  
        for (int j = 0; j < array.length - i - 1; j++) {  
            if (array[j] > array[j + 1]) {//比较相邻两数， 交换两数  
                temp = array[j];  
                array[j] = array[j + 1];  
                array[j + 1] = temp;  
            }  
        }  
    }  
}  
  
//选择
private static void selectSort(int[] array) {  
    int min;  
    int temp;  
    for (int i = 0; i < array.length - 1; i++) {  
        min = i;  
        for (int j = i + 1; j < array.length; j++) {//找出最小数  
            if (array[j] < array[min]) {  
                min = j;  
            }  
        }  
        if (min != i) {  
            temp = array[min];  
            array[min] = array[i];  
            array[i] = temp;  
        }  
    }  
}  
  
//插入  
private static void insertSort(int[] array) {  
    int temp;  
    for (int i = 1; i < array.length; i++) {  
        for (int j = i - 1; j >= 0; j--) {//array[i]依次往前比较  
            if (array[j + 1] < array[j]) {//array[j]后移一个位置  
                temp = array[j + 1];  
                array[j + 1] = array[j];  
                array[j] = temp;  
            }
        }
    }
}
  
//快速  
private static void quickSort(int[] array) {  
    if (array.length > 0) {  
        quickSort(array, 0, array.length - 1);  
    }  
}
  
private static void quickSort(int[] array, int low, int height) {  
    if (low < height) {  
        int middle = getMiddle(array, low, height);  
        quickSort(array, low, middle - 1);  
        quickSort(array, middle + 1, height);  
    }  
}
  
private static int getMiddle(int[] array, int low, int height) {  
    int temp = array[low];//第一个数作为中间数  
    while (low < height) {  
        while (low < height && temp <= array[height]) {  
            height--;  
        }  
        array[low] = array[height];//小数放在前面  
        while (low < height && temp >= array[low]) {  
            low++;  
        }  
        array[height] = array[low];//大树放在后面  
    }  
    array[low] = temp;//中间数  
    return low;  
}

为了调用方便，我们定义一个排序接口：

private interface Sortable {
    void sort(int[] array);
}

然后定义一个类实现这个接口：

    private static class BubbleSort implements Sortable {
        @Override
        public void sort(int[] array) {
            bubbleSort(array);
        }
    }

在写一个调用的方法：

    private static void doSort(Sortable sortable) {
        int[] array = Arrays.copyOf(SortTest.array, SortTest.array.length);
        System.out.print("排序前：");
        printArray(array);
        sortable.sort(array);
        System.out.print("排序后：");
        printArray(array);
        System.out.println();
    }

随机生成一个数组，作为全局变量

    private static int[] array = randomArray();
    private static int[] randomArray() {
        int length = 40;
        SecureRandom random = new SecureRandom();
        int[] array = new int[length];
        for (int i = 0; i < array.length; i++) {
            array[i] = random.nextInt(length * 100);
        }
        return array;
    }

然后就可以这样调用了：

    public static void main(String[] args) {
        doSort(new QuickSort());
        doSort(new BubbleSort());
        doSort(new SelectSort());
        doSort(new InsertSort());
    }

打印结果如下

排序前：1716, 2188, 3294, 1605, 1189, 244, 2165, 3593, 1310, 3454, 2349, 3338, 2885, 648, 1141, 1282, 2264, 1971, 341, 1699, 2165, 343, 3455, 1828, 3701, 3361, 3261, 3749, 1682, 1898, 106, 2816, 2410, 3221, 2045, 3918, 3996, 3396, 3775, 2579, 
排序后：106, 244, 341, 343, 648, 1141, 1189, 1282, 1310, 1605, 1682, 1699, 1716, 1828, 1898, 1971, 2045, 2165, 2165, 2188, 2264, 2349, 2410, 2579, 2816, 2885, 3221, 3261, 3294, 3338, 3361, 3396, 3454, 3455, 3593, 3701, 3749, 3775, 3918, 3996, 

排序前：1716, 2188, 3294, 1605, 1189, 244, 2165, 3593, 1310, 3454, 2349, 3338, 2885, 648, 1141, 1282, 2264, 1971, 341, 1699, 2165, 343, 3455, 1828, 3701, 3361, 3261, 3749, 1682, 1898, 106, 2816, 2410, 3221, 2045, 3918, 3996, 3396, 3775, 2579, 
排序后：106, 244, 341, 343, 648, 1141, 1189, 1282, 1310, 1605, 1682, 1699, 1716, 1828, 1898, 1971, 2045, 2165, 2165, 2188, 2264, 2349, 2410, 2579, 2816, 2885, 3221, 3261, 3294, 3338, 3361, 3396, 3454, 3455, 3593, 3701, 3749, 3775, 3918, 3996, 

排序前：1716, 2188, 3294, 1605, 1189, 244, 2165, 3593, 1310, 3454, 2349, 3338, 2885, 648, 1141, 1282, 2264, 1971, 341, 1699, 2165, 343, 3455, 1828, 3701, 3361, 3261, 3749, 1682, 1898, 106, 2816, 2410, 3221, 2045, 3918, 3996, 3396, 3775, 2579, 
排序后：106, 244, 341, 343, 648, 1141, 1189, 1282, 1310, 1605, 1682, 1699, 1716, 1828, 1898, 1971, 2045, 2165, 2165, 2188, 2264, 2349, 2410, 2579, 2816, 2885, 3221, 3261, 3294, 3338, 3361, 3396, 3454, 3455, 3593, 3701, 3749, 3775, 3918, 3996, 

排序前：1716, 2188, 3294, 1605, 1189, 244, 2165, 3593, 1310, 3454, 2349, 3338, 2885, 648, 1141, 1282, 2264, 1971, 341, 1699, 2165, 343, 3455, 1828, 3701, 3361, 3261, 3749, 1682, 1898, 106, 2816, 2410, 3221, 2045, 3918, 3996, 3396, 3775, 2579, 
排序后：106, 244, 341, 343, 648, 1141, 1189, 1282, 1310, 1605, 1682, 1699, 1716, 1828, 1898, 1971, 2045, 2165, 2165, 2188, 2264, 2349, 2410, 2579, 2816, 2885, 3221, 3261, 3294, 3338, 3361, 3396, 3454, 3455, 3593, 3701, 3749, 3775, 3918, 3996, 

由此可见，排序代码都是对的，可以正确排序数组。

接下来就可以比较这几种排序算法的耗时情况了，为了尽可能使结果具有说服性，随机生成1000个长度为400的数组，计算对这100个数组排序的总耗时，另外要保证几种算法所排序的数组都一样，对调用方法做出如下修改：

    private static ArrayList<int[]> arrays = new ArrayList<>();

    static {
        for (int i = 0; i < 100; i++) {
            arrays.add(randomArray());
        }
    }
    
    private static ArrayList<int[]> copyList(ArrayList<int[]> arrays) {
        ArrayList<int[]> result = new ArrayList<>();
        for (int[] array : arrays) {
            result.add(Arrays.copyOf(array, array.length));
        }
        return result;
    }

    private static void doSort(Sortable sortable) {
        ArrayList<int[]> arrays = copyList(SortTest.arrays);
        long start = System.currentTimeMillis();
        for (int[] array : arrays) {
            sortable.sort(array);
        }
        System.out.println(sortable.getClass().getSimpleName() + " 用时 : " + (System.currentTimeMillis() - start));
    }

执行几次的输出结果：

QuickSort 用时 : 21
BubbleSort 用时 : 148
SelectSort 用时 : 55
InsertSort 用时 : 44

QuickSort 用时 : 18
BubbleSort 用时 : 141
SelectSort 用时 : 50
InsertSort 用时 : 49

QuickSort 用时 : 21
BubbleSort 用时 : 140
SelectSort 用时 : 50
InsertSort 用时 : 48

QuickSort 用时 : 27
BubbleSort 用时 : 151
SelectSort 用时 : 50
InsertSort 用时 : 46

QuickSort 用时 : 21
BubbleSort 用时 : 144
SelectSort 用时 : 50
InsertSort 用时 : 43

可以看到结果，快速排序果然是最快的。另外，冒泡排序最慢，而且慢很多，虽然理论上时间复杂度和选择排序、插入排序一样。我们把数组长度增加到1000，再看结果：

QuickSort 用时 : 45
BubbleSort 用时 : 831
SelectSort 用时 : 241
InsertSort 用时 : 218

QuickSort 用时 : 45
BubbleSort 用时 : 790
SelectSort 用时 : 243
InsertSort 用时 : 239

QuickSort 用时 : 44
BubbleSort 用时 : 763
SelectSort 用时 : 245
InsertSort 用时 : 223

QuickSort 用时 : 45
BubbleSort 用时 : 789
SelectSort 用时 : 239
InsertSort 用时 : 221

QuickSort 用时 : 46
BubbleSort 用时 : 820
SelectSort 用时 : 246
InsertSort 用时 : 218

可以看到，快速排序的优势更加明显，已经相差一个数量级，如果增加到10000呢：

QuickSort 用时 : 569
BubbleSort 用时 : 89151
SelectSort 用时 : 20424
InsertSort 用时 : 21730

可见，快速排序不是白叫的，已经领先3个数量级。