时间复杂度比较
- 排序算法
- 仿真比较
排序算法
仿真比较
导入的时间计算器,将这个脚本的文件名命令为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)
时间: 快排<堆排序<选择排序<插入排序<冒泡