算法导论 第六章 2 优先队列（python）

优先队列：

    物理结构： 顺序表(典型的是数组){python用到list}

    逻辑结构：似完全二叉树

使用的特点是：动态的排序。。排序的元素会增加，减少#和快速排序对比 快速一次排完 增加元素要重排（或许是插入）

                        随插随排

                        每次拿一个最大（最大（优先队列/堆））或最小

关键注意点：

    A.length：元素个数 #python 我将用len（A） - 1  #第一位将用-1舍弃

    A.heap_size : 在堆中元素的个数  不一定等于 A.length{这个不好理解，可以看看堆排序的最后一步}

 

'''
最大优先队列

'''
def PARENT(i):
    return i//2

def LEFT(i):
    return i*2

def RIGHT(i):
    return i*2 + 1


class Mylist(list):
    def __init__(self):
        self.heap_size = 0
        super().__init__()


def MAX_HEAPIFY(A,i):
    l = LEFT(i)
    r = RIGHT(i)

    #找出最大的结点
    
    #i的左孩子是否大于i
    #A.heap_size 写一个继承了list类 类中加上这个参数（Mylist）
    #或者选择A[0] 位放heap_size ??
    #或者设计全局变量
    if l <= A.heap_size and A[l] > A[i]:
        largest = l
    else:
        largest = i
    #和右孩子比
    if r <= A.heap_size and A[r] > A[largest]:
        largest = r
    if largest != i: #如果A[i]不是最大的 就要调堆了
        A[i],A[largest] = A[largest],A[i] #交换
        MAX_HEAPIFY(A,largest) #递归调largest

def BUILD_MAX_HEAP(A):
    A.heap_size = len(A)-1
    #print(len(A))
    for i in range(A.heap_size//2,0,-1): #从n//2开始到1
        #print(i)
        MAX_HEAPIFY(A,i)


def HEAP_MAXMUM(A):
    return A[1] #同堆第一位最后大

def HEAP_EXTRACT_MAX(A): #去除最大元素 同堆排序中HEAPSORT(A)中的一步
    if A.heap_size < 1:
        raise OverflowError("heap underflow")
    max = A[1]
    A[1] = A[A.heap_size]
    A.heap_size -= 1
    MAX_HEAPIFY(A,1)#调堆
    return max

def HEAP_INCREASE_KEY(A,i,key):#增加关键字权值
    if key < A[i]:
        print("new key is smaller than current key")
        return
    A[i] = key
    while i > 1 and A[PARENT(i)] < A[i]: #调堆
        A[i],A[PARENT(i)] = A[PARENT(i)],A[i]
        i = PARENT(i)

def MAX_HEAP_INSERT(A,key):#插入
    A.heap_size += 1
    A.append(-10000)
    #A[A.heap_size] = -10000#- -!
    HEAP_INCREASE_KEY(A,A.heap_size,key)

    
    
    
    

if __name__ == '__main__':
    A = Mylist()
    for i in[-1,4,1,3,2,16,9,10,14,8,7]: #A = [,...] A会变成list
        A.append(i)
    BUILD_MAX_HEAP(A)
    print("建成的堆:",A)
    MAX_HEAP_INSERT(A,20)
    MAX_HEAP_INSERT(A,5)
    print("插入后的堆:",A)
    print("取最大关键字： ",end='')
    print(HEAP_EXTRACT_MAX(A))
    print("堆变成 ",A)
    print("取最大关键字： ",end='')
    print(HEAP_EXTRACT_MAX(A))
    print("堆变成 ",A)
    
    

'''
============ RESTART: F:/python/algorithms/6_5_priority_queue.py ============
建成的堆: [-1, 16, 14, 10, 8, 7, 9, 3, 2, 4, 1]
插入后的堆: [-1, 20, 16, 10, 8, 14, 9, 3, 2, 4, 1, 7, 5]
取最大关键字： 20
堆变成  [-1, 16, 14, 10, 8, 7, 9, 3, 2, 4, 1, 5, 5] #注意在末尾的不包括在A.heap_size 中
取最大关键字： 16
堆变成  [-1, 14, 8, 10, 5, 7, 9, 3, 2, 4, 1, 5, 5]

环境win7 + python3.5.1
'''

转载于:https://www.cnblogs.com/liguan/p/5174581.html