题目:复现下面的图片
import sys # 导入sys模块
sys.setrecursionlimit(3000) # 将默认的递归深度修改为3000
import random
import time
import matplotlib.pyplot as plt
from heapq import merge
import numpy as np
#插入排序
def insertion_sort(arr):
for i in range(1, len(arr)):
key = arr[i]
j = i - 1
while j >= 0 and key < arr[j]:
arr[j + 1] = arr[j]
j -= 1
arr[j + 1] = key
return arr
#堆排序
def heap_sort(array):
first = len(array) // 2 - 1
for start in range(first, -1, -1):
# 从下到上,从右到左对每个非叶节点进行调整,循环构建成大顶堆
big_heap(array, start, len(array) - 1)
for end in range(len(array) - 1, 0, -1):
# 交换堆顶和堆尾的数据
array[0], array[end] = array[end], array[0]
# 重新调整完全二叉树,构造成大顶堆
big_heap(array, 0, end - 1)
return array
def big_heap(array, start, end):
root = start
# 左孩子的索引
child = root * 2 + 1
while child <= end:
# 节点有右子节点,并且右子节点的值大于左子节点,则将child变为右子节点的索引
if child + 1 <= end and array[child] < array[child + 1]:
child += 1
if array[root] < array[child]:
# 交换节点与子节点中较大者的值
array[root], array[child] = array[child], array[root]
# 交换值后,如果存在孙节点,则将root设置为子节点,继续与孙节点进行比较
root = child
child = root * 2 + 1
else:
break
#归并排序
def merge_sort(lst):
if len(lst) <= 1:
return lst # 从递归中返回长度为1的序列
middle = len(lst) // 2
left = merge_sort(lst[:middle]) # 通过不断递归,将原始序列拆分成n个小序列
right = merge_sort(lst[middle:])
return list(merge(left, right))
#快速排序
def quick_sort(array, start, end):
if start >= end:
return
mid_data, left, right = array[start], start, end
while left < right:
while array[right] >= mid_data and left < right:
right -= 1
array[left] = array[right]
while array[left] < mid_data and left < right:
left += 1
array[right] = array[left]
array[left] = mid_data
quick_sort(array, start, left - 1)
quick_sort(array, left + 1, end)
if __name__ == '__main__':
insertarray = []
heaparray = []
mergearray = []
quickarray = []
global array
array = []
for n in range(0,101,10):
array=[random.randint(0,300) for _ in range(n) ]
print("随机后:",array)
print("数组中含有",n,"个元素时")
insertstart_time = time.perf_counter()
insertion_sort(array)
print(array)
insertend_time = time.perf_counter()
insertrun_time = insertend_time - insertstart_time
print("插入排序程序运行时间为:", insertrun_time*1000000, "微秒")
insertarray.append(insertrun_time*10000)
print("插入排序时间数组:",quickarray)
array=[]
for n in range(0,101,10):
array=[random.randint(0,300) for _ in range(n) ]
print("随机后:",array)
print("数组中含有",n,"个元素时")
heapstart_time = time.perf_counter()
heap_sort(array)
print(array)
heapend_time = time.perf_counter()
heaprun_time = heapend_time - heapstart_time
print("堆排序程序运行时间为:", heaprun_time*1000000, "微秒")
heaparray.append(heaprun_time*10000)
print("堆排序时间数组:",quickarray)
array=[]
for n in range(0,101,10):
array=[random.randint(0,300) for _ in range(n) ]
print("随机后:", array)
print("数组中含有", n, "个元素时")
mergestart_time = time.perf_counter()
merge_sort(array)
mergeend_time = time.perf_counter()
mergerun_time = mergeend_time - mergestart_time
print("归并排序程序运行时间为:", mergerun_time * 1000000, "微秒")
mergearray.append(mergerun_time *10000)
print("归并排序时间数组:",mergearray)
array = []
for n in range(0, 101, 10):
array = [random.randint(0, 300) for _ in range(n)]
print("随机后:",array)
print("数组中含有",n,"个元素时")
quickstart_time = time.perf_counter()
quick_sort(array, 0, len(array)-1)
print(array)
quickend_time = time.perf_counter()
quickrun_time = quickend_time - quickstart_time
print("快速排序程序运行时间为:", quickrun_time*1000000, "微秒")
quickarray.append(quickrun_time*10000)
print("快排数组时间数组:",quickarray)
array=[]
#设置横纵坐标
plt.xlabel('n')
plt.ylabel("t(us)*10-3")
# 绘制图形
new_insertarray=[]
new_heaparray=[]
new_mergearray=[]
new_quickarray=[]
i=[0,10,20,30,40,50,60,70,80,90,100]
#print(i)
plt.plot(i,insertarray,color='red',marker='o',label="insert_sort")
plt.plot(i,heaparray,color='green',marker='o',label="heap_sort")
plt.plot(i,mergearray,color='yellow',marker='o',label="merge_sort")
plt.plot(i,quickarray,color='blue',marker='o',label="quick_sort")
plt.xticks([0, 10,20,30, 40,50, 60,70, 80,90,100])
# 显示图形
plt.show()
最终结果由于本程序中归并排序的递归深度太大,运行不出结果,将其注释后,可有如下结果图:
已知排序时间复杂度如下:
基本符合代码运行结果(除了归并排序没有图像),有大神能解决归并排序的递归深度问题吗?
新手小白,如有错误,虚心求教!