【动手学数据结构—排序算法复杂度（Python）】

排序算法

仿真比较

导入的时间计算器，将这个脚本的文件名命令为comput_time.py即可

def print_execute_time(func):
    from time import time

    # 定义嵌套函数，用来打印出装饰的函数的执行时间
    def wrapper(*args, **kwargs):
        # 定义开始时间和结束时间，将func夹在中间执行，取得其返回值
        start = time()
        func_return = func(*args, **kwargs)
        end = time()
        # 打印方法名称和其执行时间
        print(f'{func.__name__}() execute time: {end - start}s')
        # 返回func的返回值
        return func_return

    # 返回嵌套的内层函数
    return wrapper

from comput_time import *
import random
import copy


# 冒泡排序 复杂度 o(n^2)
@print_execute_time
def buf_sort(li):
    Le = len(li) - 1
    for i in range(len(li)):
        exchange = False
        for j in range((len(li)-i-1)):
            if li[Le-j] < li[Le-j-1]:
                li[Le-j], li[Le-j-1] = li[Le-j-1], li[Le-j]
                exchange = True
        if exchange:
            # print(li)
            pass
        else:
            return None


@print_execute_time
def insert_sort(li):  # 插入排序
    for i in range(1, len(li)):
        for j in range(i-1, -1, -1):
            if li[j] > li[j+1]:
                li[j], li[j+1] = li[j+1], li[j]


@print_execute_time
def select_sort(li):   # 选择排序
    for i in range(len(li)):
        min_index = i
        for j in range(i+1, len(li)):
            if li[j] < li[min_index]:
                min_index = j
        if i != min_index:
            li[i], li[min_index] = li[min_index], li[i]
        else:
            return 0
    return 0


def paratition(li, left, right):
    temp = li[left]  # 用temp变量暂存第一个元素
    while left < right:  # 当left和right两个指标的位置没碰到时，继续更替
        while left < right and li[right] >= temp:  # 第一个条件防止right小于left 第二个条件则是查找的核心条件
            right -= 1  # 如果这个位置大于temp 则往上找
        li[left] = li[right] # 找到了！ 换
        while left < right and li[left] <= temp: # 与上一个while同理
            left += 1
        li[right] = li[left]
    li[left] = temp  # 最后更替到left与right重叠的时候，再把temp放回最中间，因为temp在列表中被拿走了
    return left  # 返回中心位置


def _quick_sort(li, left, right):
    if left < right: # 递归终止条件：left=right,写成while的话会造成死循环。
        mid = paratition(li, left, right)  # 调用函数，取第一个元素排序后的索引
        # 两边递归调用，完成排序
        _quick_sort(li, left, mid-1)
        _quick_sort(li, mid+1, right)


@print_execute_time
def quick_sort(li):  # 快速排序
    _quick_sort(li, 0, len(li)-1)


def sift(li, low, high):
    i = low  # 根节点
    temp = li[i]
    j = 2*i + 1  # 左孩子节点
    while j <= high:
        if j + 1 < high and li[j + 1] > li[j]:  # 防止右孩子节点溢出，如果右孩子节点大于左孩子节点，则右孩子节点接替父节点
            j = j + 1  # j指向右孩子节点
        if temp < li[j]: # 如果当前i指向的要小于j指向的孩子节点，则孩子节点上位
            li[i] = li[j]
            # 往下看一层
            i = j
            j = 2*i + 1
        else:
            li[i] = temp  # 此时树结构中temp不存在，需要把temp放回来 (在树的上面放)
            break
    else:
        li[i] = temp # 此时树结构中temp不存在，需要把temp放回来 (在树的最底层放)


@print_execute_time
def heap_sort(li):  # 堆排序
    n = len(li)
    # 生成堆
    for i in range((n-2)//2, -1, -1):
        # 子树向下调整
        sift(li, i, n-1)
    # 排序
    for i in range(n-1, -1, -1):
        li[0], li[i] = li[i], li[0]  # 节约内存，堆顶与最后一个元素互换
        sift(li, 0, i-1)  # 此时最后一个元素应该是i-1,因为第i个是暂存堆顶的元素


Li = [random.randint(0, 300) for _ in range(10000)]
random.shuffle(Li)
l1 = copy.deepcopy(Li)
l2 = copy.deepcopy(Li)
l3 = copy.deepcopy(Li)
l4 = copy.deepcopy(Li)
l5 = copy.deepcopy(Li)
quick_sort(l1)
heap_sort(l2)
buf_sort(l3)
insert_sort(l4)
select_sort(l5)

时间： 快排<堆排序<选择排序<插入排序<冒泡