先决条件：堆排序
堆排序是一种基于二叉堆数据结构的比较排序技术。它类似于我们首先找到最大元素并将最大元素放在最后的选择排序。我们对剩余元素重复相同的过程。
我们在这里实现堆排序，为不同大小的随机列表调用它，测量不同大小所花费的时间并生成输入大小与所花费时间的图。
# Python Code for Implementation and running time Algorithm
# Complexity plot of Heap Sort
# by Ashok Kajal
# This python code intends to implement Heap Sort Algorithm
# Plots its time Complexity on list of different sizes
# ---------------------Important Note -------------------
# numpy, time and matplotlib.pyplot are required to run this code
import time
from numpy.random import seed
from numpy.random import randint
import matplotlib.pyplot as plt
# find left child of node i
def left(i):
return 2 * i + 1
# find right child of node i
def right(i):
return 2 * i + 2
# calculate and return array size
def heapSize(A):
return len(A)-1
# This function takes an array and Heapyfies
# the at node i
def MaxHeapify(A, i):
# print("in heapy", i)
l = left(i)
r = right(i)
# heapSize = len(A)
# print("left", l, "Rightt", r, "Size", heapSize)
if l<= heapSize(A) and A[l] > A[i] :
largest = l
else:
largest = i
if r<= heapSize(A) and A[r] > A[largest]:
largest = r
if largest != i:
# print("Largest", largest)
A[i], A[largest]= A[largest], A[i]
# print("List", A)
MaxHeapify(A, largest)
# this function makes a heapified array
def BuildMaxHeap(A):
for i in range(int(heapSize(A)/2)-1, -1, -1):
MaxHeapify(A, i)
# Sorting is done using heap of array
def HeapSort(A):
BuildMaxHeap(A)
B = list()
heapSize1 = heapSize(A)
for i in range(heapSize(A), 0, -1):
A[0], A[i]= A[i], A[0]
B.append(A[heapSize1])
A = A[:-1]
heapSize1 = heapSize1-1
MaxHeapify(A, 0)
# randomly generates list of different
# sizes and call HeapSort funtion
elements = list()
times = list()
for i in range(1, 10):
# generate some integers
a = randint(0, 1000 * i, 1000 * i)
# print(i)
start = time.clock()
HeapSort(a)
end = time.clock()
# print("Sorted list is ", a)
print(len(a), "Elements Sorted by HeapSort in ", end-start)
elements.append(len(a))
times.append(end-start)
plt.xlabel('List Length')
plt.ylabel('Time Complexity')
plt.plot(elements, times, label ='Heap Sort')
plt.grid()
plt.legend()
plt.show()
# This code is contributed by Ashok Kajal
输出 ：
输入：通过堆排序中0.1658182863213824 6000元素排序1000元素排序通过堆排序中0.023797415087301488 2000元素排序通过堆排序中0.053856713614550245 3000元素排序通过堆排序中0.08474737185133563 4000元素排序通过堆排序中0.13578669978414837 5000元素排序：不同尺寸的未排序列表是随机产生输出按 HeapSort 在 0.1875901601906662 中按 HeapSort 在 0.21982946862249264 中按 HeapSort 排序的 7000 个元素在 0.2724293921580738 中按 HeapSort 在 0.27242938 中按 HeapSort 排序的 7000 个元素进行排序 9000000000000000000336 个复杂的 Heap23034 个复杂的 90000034 个元素。 
如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。