常用排序算法的python实现

插入排序，时间复杂度为O(n^2)：

def InsertionSort(a):
    for i in range(1, len(a)):
        key = a[i]  # 每轮要插入的元素赋值为key
        j = i-1
        while j >= 0 and a[j] > key:  # 寻找key要插入的位置
            a[j+1] = a[j]  # key到插入位置之间的元素都后移一位
            j -= 1
        a[j+1] = key  # 插入key

冒泡排序，时间复杂度为O(n^2)：

def BubbleSort(a):
    for i in range(len(a)-1):  # 每一轮冒泡将列表中最大的元素移到列表末尾
        for j in range(len(a)-1-i):  # 每一轮冒泡仍然从第一个元素开始
            if a[j] > a[j+1]:
                a[j], a[j+1] = a[j+1], a[j]

选择排序，时间复杂度为O(n^2)：

def SelectionSort(a):
    for i in range(len(a)-1):
        m = i
        for j in range(i+1, len(a)):
            if a[j] < a[m]:  # 寻找从i+1到列表末尾最小的元素
                m = j
        if m != i:
            a[i], a[m] = a[m], a[i]  # 如果从i+1到列表末尾最小的元素比第i个元素小，则交换

归并排序，时间复杂度为O(n*logn)：

def MergeSort(a):
    if len(a) <= 1:  # 递归到只有一个元素时输出
        return a
    mid = int(len(a)/2)  # 将列表一分为二
    left = MergeSort(a[:mid])  # 排序左半边元素
    right = MergeSort(a[mid:])  # 排序右半边元素
    return Merge(left, right)  # 合并两边元素


def Merge(left, right):  # 归并两个已排序列表
    r, l = 0, 0
    result = []
    while l < len(left) and r < len(right):
        if left[l] < right[r]:
            result.append(left[l])
            l += 1
        else:
            result.append(right[r])
            r += 1  # 此时left与right之一已经归并完毕，只需将另一个列表的剩余部分加到result末尾
    result += list(left[l:])
    result += list(right[r:])
    return result

快速排序，时间复杂度为O(n*logn)：

def QuickSort(a):
    if len(a) >= 2:
        mid = a[int(len(a)/2)]  # 选取列表中间元素为基准值
        left, right = [], []
        a.remove(mid)  # 先去掉基准值，将剩下的元素分为比基准值大和比基准值小的两类再合并
        for num in a:
            if num >= mid:
                right.append(num)  # 比基准值大的排到右边
            else:
                left.append(num)  # 比基准值小的排到左边
        return QuickSort(left) + [mid] + QuickSort(right)  # 将基准值放到中间
    else:
        return a

计算每种排序算法的运算时间：

import numpy as np
import time
from Sort import InsertionSort, BubbleSort, SelectionSort, MergeSort, QuickSort


def sort(method='insertion'):

    a = np.random.randint(low=0, high=1000, size=1000)  # 随机生成1000个0到1000之间的整数并存到列表中
    a = list(a)
    before = time.time()

    if method == 'insertion':  # 插入排序
        InsertionSort.InsertionSort(a)

    elif method == 'bubble':  # 冒泡排序
        BubbleSort.BubbleSort(a)

    elif method == 'selection':  # 选择排序
        SelectionSort.SelectionSort(a)

    elif method == 'merge':  # 归并排序
        MergeSort.MergeSort(a)

    elif method == 'quick':  # 快速排序
        QuickSort.QuickSort(a)

    after = time.time()
    operation_time = after - before  # 计算运行时间

    return operation_time


insertion_time = sort('insertion')
print("插入排序运算时间：", insertion_time, "s")
# 插入排序时间复杂度为O(n^2)

bubble_time = sort('bubble')
print("冒泡排序运算时间：", bubble_time, "s")
# 冒泡排序时间复杂度为O(n^2)

selection_time = sort('selection')
print("选择排序运算时间：", selection_time, "s")
# 选择排序时间复杂度为O(n^2)

merge_time = sort('merge')
print("归并排序运算时间：", merge_time, "s")
# 归并排序时间复杂度为O(n*logn)

quick_time = sort('quick')
print("快速排序运算时间：", quick_time, "s")
# 快速排序时间复杂度为O(n*logn)

结果如下：

插入排序运算时间： 0.07932186126708984 s
冒泡排序运算时间： 0.17637372016906738 s
选择排序运算时间： 0.09382295608520508 s
归并排序运算时间： 0.009192705154418945 s
快速排序运算时间： 0.0040683746337890625 s