算法导论--分治策略，多种排序算法的速度比较

题目：复现下面的图片

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()

最终结果由于本程序中归并排序的递归深度太大，运行不出结果，将其注释后，可有如下结果图：

已知排序时间复杂度如下：

基本符合代码运行结果（除了归并排序没有图像），有大神能解决归并排序的递归深度问题吗？
新手小白，如有错误，虚心求教！