堆

 

import math
#定义一个类，堆
class heap:
    def __init__(self,A):
        self.list=A#堆是由列表得来
        self.heap_size = len(A)#堆的大小是列表的长度
    def parent(self,i):
        #i的父节点
        return math.floor((i-1)/2)
    def left(self,i):
        #i的左节点
        return 2*i+1
    def right(self,i):
        #i的右节点
        return 2*i+2
------------------------------------------------------
A=[4,1,3,2,16,9,10,14,8,7]
H=heap(A)
print(H)

，h是树高

#要求：以list中第i个元素为根节点的子树满足最大堆要求，
# 输入一个堆和他的某个元素，返回满足要求的堆的列表形式
def max_heapify(H,i):
    A=H.list
    largest = i#默认初始最大值的下标为i
    l = H.left(i)#l是i的左节点下标
    r = H.right(i)#r是i的右节点下标
    if l<H.heap_size and A[l] > A[largest]:
        largest = 2*i+1
    if r<H.heap_size and A[r] > A[largest]:
        largest = 2*i+2
    #从A【i】,A[left(i)],A[right(i)]中选出最大的，将其下标存储在largest中
    if largest != i:
        #如果i不是最大的，则交换A[i]和A[largest]，
        #此时下标largest的节点的值是原来的A【i】,对该子树进行递归调用
        A[i], A[largest] = A[largest], A[i]
        max_heapify(H,largest)
    return A

A=[4,1,3,2,16,9,10,14,8,7]
H=heap(A)
print(max_heapify(H,0))
-----------------------------------------------
[4, 1, 3, 2, 16, 9, 10, 14, 8, 7]

 

#建立最大堆，输入一个堆，返回满足最大堆的列表
def build_max_heap(H):
    A = H.list
    N = math.floor(H.heap_size/2)-1
    #对于每个节点，要求满足最大堆的规则
    for i in range(N,-1,-1):
        max_heapify(H,i)
    return A

print(build_max_heap(H))
---------------------------------------
[16, 14, 10, 8, 7, 9, 3, 2, 4, 1]

#堆排序，输入一个堆，通过迭代建立最大堆并每次取出堆的最大值放在最后面，来从小到大排序
def heapsort(H):
    A = H.list
    build_max_heap(H)
    #利用heap_size从堆中去掉节点n
    for i in range(H.heap_size - 1, 0, -1):
        A[i],A[0]=A[0],A[i]
        H.heap_size-=1
        max_heapify(H, 0)
    return A
print(heapsort(H))
------------------------------------------------------------
[1, 2, 3, 4, 7, 8, 9, 10, 14, 16]

 

#提取最大堆的最大元素，并且去掉它，再对于其余的进行最大堆化
#并没有对他排序，但任然能提取最大元素
def heap_extract_max(H):
    if  H.heap_size<1:
        raise ('heap underflow')
    A = H.list
    max=A[0]
    A[0]=A[H.heap_size-1]
    H.heap_size-=1
    max_heapify(H,0)
    return max
A=[4,1,3,2,16,9,10,14,8,7]
H=heap(A)
p=build_max_heap(H)
print(p)
B=heap(p)
print(heap_extract_max(B))
print(heap_extract_max(B))
print(heap_extract_max(B))
print(heap_extract_max(B))
print(heap_extract_max(B))
-----------------------------------------------------
[16, 14, 10, 8, 7, 9, 3, 2, 4, 1]
16
14
10
9
8

 

#修改某个关键字，把关键字放到合适位置，使他满足最大堆性质
def heap_increase_key(A,i,key):
    H=heap(build_max_heap(heap(A)))
    if key < A[i]:
        raise("new key is smaller than current key")
    A[i]=key
    while i>0 and A[H.parent(i)]<A[i]:
        A[i],A[H.parent(i)]=A[H.parent(i)],A[i]
        i=H.parent(i)

A=[4,1,3,2,16,9,10,14,8,7]
print(A)
heap_increase_key(A,8,15)
print(A)
------------------------------------------------------------
[4, 1, 3, 2, 16, 9, 10, 14, 8, 7]
[16, 15, 10, 14, 7, 9, 3, 2, 8, 1]

#他的输入是要被插入到最大堆中的新元素的关键字
def max_heap_insert(A,key):
    A.append(float("-inf"))
    heap_increase_key(A,len(A)-1,key)


A=[4,1,3,2,16,9,10,14,8,7]
print(A)
max_heap_insert(A,13)
print(A)
-----------------------------------------------
[4, 1, 3, 2, 16, 9, 10, 14, 8, 7]
[16, 14, 10, 8, 13, 9, 3, 2, 4, 1, 7]