堆排序和优先队列的python实现

堆排序算法：

def HeapSort(a):
    global heapsize
    BuildMaxHeap(a)
    i = len(a)-1
    while i >= 1:
        a[0], a[i] = a[i], a[0]
        heapsize -= 1
        MaxHeapify(a, 0)
        i -= 1

主要步骤如下：

1.建堆(得到最大堆)

def BuildMaxHeap(a):
    global heapsize
    heapsize = len(a)
    i = math.floor(len(a)/2)-1
    while i >= 0:
        MaxHeapify(a, i)
        i -= 1

2.交换元素(最大元素定位)

3.最大堆维护(子序列中【除去上一步的最大元素】，最大堆性质被破坏了)，然后回到第3步

def MaxHeapify(a, i):
    global heapsize
    l = 2*i+1
    r = 2*i+2
    if l < heapsize and a[l] > a[i]:
        largest = l
    else:
        largest = i
    if r < heapsize and a[r] > a[largest]:
        largest = r
    if largest != i:
        a[i], a[largest] = a[largest], a[i]
        MaxHeapify(a, largest)

优先队列算法：

EXTRACT-MAX(A)：去掉并返回A中的具有最大键字的元素

def HeapExtractMax(a):
    global heapsize
    if heapsize < 1:
        print("heap underflow")
        return
    max = a[0]
    a[0] = a[heapsize-1]
    heapsize -= 1
    MaxHeapify(a, 0)
    return max

INCREASE-KEY(A, i, key)：将元素i的关键字值增加到key，这里假设key的值不小于i

def HeapIncreaseKey(a, i, key):
    if key < a[i]:
        print("new key is smaller than current key")
        return
    a[i] = key
    while i > 0 and a[math.floor((i-1)/2)] < a[i]:
        a[i], a[math.floor((i-1)/2)] = a[math.floor((i-1)/2)], a[i]
        i = math.floor((i-1)/2)

INSERT(A, key)：将元素key插入集合A中

def MaxHeapInsert(a, key):
    global heapsize
    heapsize += 1
    a[heapsize-1] = 0
    HeapIncreaseKey(a, heapsize-1, key)

用最小堆实现堆排序和优先队列：

import math
import time
import numpy as np
global heapsize


def BuildMinHeap(a):
    global heapsize
    heapsize = len(a)
    i = math.floor(len(a)/2)-1
    while i >= 0:
        MinHeapify(a, i)
        i -= 1


def MinHeapify(a, i):
    global heapsize
    l = 2*i+1
    r = 2*i+2
    if l < heapsize and a[l] < a[i]:
        smallest = l
    else:
        smallest = i
    if r < heapsize and a[r] < a[smallest]:
        smallest = r
    if smallest != i:
        a[i], a[smallest] = a[smallest], a[i]
        MinHeapify(a, smallest)


def HeapSort(a):
    global heapsize
    BuildMinHeap(a)
    i = len(a)-1
    while i >= 1:
        a[0], a[i] = a[i], a[0]
        heapsize -= 1
        MinHeapify(a, 0)
        i -= 1


def HeapExtractMin(a):
    global heapsize
    if heapsize < 1:
        print("heap underflow")
        return
    min = a[0]
    a[0] = a[heapsize-1]
    heapsize -= 1
    MinHeapify(a, 0)
    return min


def HeapIncreaseKey(a, i, key):
    if key > a[i]:
        print("new key is larger than current key")
        return
    a[i] = key
    while i > 0 and a[math.floor((i-1)/2)] > a[i]:
        a[i], a[math.floor((i-1)/2)] = a[math.floor((i-1)/2)], a[i]
        i = math.floor((i-1)/2)


def MinHeapInsert(a, key):
    global heapsize
    heapsize += 1
    a[heapsize-1] = 0
    HeapIncreaseKey(a, heapsize-1, key)


def main():
    a = np.random.randint(low=0, high=1000, size=1000)  # 随机生成1000个0到1000之间的整数并存到列表中
    a = list(a)

    before = time.time()
    HeapSort(a)
    after = time.time()
    operation_time = after - before  # 计算运行时间

    print("堆排序运算时间：", operation_time, "s")
    # 堆排序时间复杂度为O(n*logn)


if __name__=='__main__':
    main()

结果如下：

堆排序运算时间： 0.006556272506713867 s