Python三种排序算法的运行速度对比(快速排序、冒泡排序、选择排序)

最近看了一下快速排序算法，据说速度比其他的排序算法快，于是写了三个排序算法对比一下，分别是冒泡排序，快速排序，选择排序，以下是三个排序算法的代码：

冒泡排序   BubbleSort.py

# -*- coding:utf8 -*-

def Sort(list):
    num = len(list)
    for i in range(0, num-1):
        isSortOver = True
        for j in range(i+1, num):
            if list[i] > list[j]:
                isSortOver = False
                list[i], list[j] = list[j], list[i]
        if isSortOver:
                break
    return list

选择排序   SelectSort.py

# -*- coding:utf8 -*-

def Sort(list):
    for i in range(0, len(list)-1):
        minIndex = i
        for j in range(i+1, len(list)):
            if list[j] < list[minIndex]:
                minIndex = j
        list[i], list[minIndex] = list[minIndex], list[i]
    return list

快速排序   QuickSort.py

# -*- coding:utf8 -*-

def Sort(list):
    SortList(list, 0, len(list)-1)
    return list

def SortList(list, low, high):
    if low < high:
        k_index = DealList(list, low, high)
        SortList(list, low, k_index - 1)
        SortList(list, k_index + 1, high)

def DealList(list, low, high):
    left = low
    right = high
    k = list[low]

    while left < right:#左右两个指针逐渐向中间靠近
        while list[right] > k:
            right -= 1
        while left < len(list) and list[left] <= k:#确保左边指针不会越界
            left += 1
        if left < right:
            list[right], list[left] = list[left], list[right]

    list[low] = list[right]
    list[right] = k
    return right

看完代码以后，我们首先一个很直观的感觉就是，快速排序算法要比另外两个复杂很多。但是对于计算机的可能并不如此。

接着我们写一个测试文件   SortTest.py

# -*- coding:utf8 -*-

import time
import random
import QuickSort
import BubbleSort
import SelectSort

list = [random.randint(1, 100) for i in range(100)]#创建一个100个元素的1到99的随机集合
start = time.clock()
print QuickSort.Sort(list)
# print BubbleSort.Sort(list)
# print SelectSort.Sort(list)
end = time.clock()
print "%.8f" %(end - start)

通过导入time模块的clock方法，我们可以准确计算出计算机执行排序方法所用的时间，通过对100个元素的随机数集合进行的排序，我们每个排序方法测试10次，取平均值，得到以下数据

快速排序：0.46770ms

冒泡排序：0.80125ms

选择排序：0.61256ms

得出结论，在当前数量和复杂度的排序中，快速排序为最优解。