二叉堆这个数据结构有点意思，自己做了个总结，内容结构如下：

二叉堆性质

二叉堆操作

应用

二叉堆性质：

堆(Heap)是一个可以被看成近似完全二叉树的结构，具有完全二叉树的特性：

缺少的叶子节点总是位于右子节点

n个节点的完全二叉树高度：k=⌊ log2n⌋(向上取整)

从1开始按层序编号，那么第i个节点有如下性质：

其左子节点索引是：2i

其又子节点索引是：2i+1

其父节点索引为 ： i // 2

同时具有堆的特性：

堆顶元素就是最值，O(1)时间就能优先拿到

从根节点(堆顶)到堆中每一个节点都是一个有序序列。

存储方式可以用线性的数组来实现，实现简单易操作，不过要注意数组下标从0开始，这个位置预留占位，节点的索引从1开始编号。

2.png

binarytree.png

二叉堆操作：

BinaryHeap()：创建一个空的二叉堆对象

insert(key)：将新元素加入到堆中

findMin()：返回堆中的最小项，最小项仍保留在堆中

delMin()：返回堆中的最小项，同时从堆中删除

isEmpty()：返回堆是否为空

size()：返回堆中节点的个数

buildHeap(lst)：从一个包含节点的列表里创建新堆

# 直接导入Pythonds包使用其提供的有关堆的数据结构。

from pythonds.trees import BinaryHeap

bheap=BinaryHeap()

bheap.insert(5)

#用list来实现对堆的操作

class BinaryHeap(object):

"""定义一个二叉堆"""

def __init__(self):

self.heapList = [0] # 第一个堆元素从1开始编号，索引为0占位不用

self.currentSize = 0

def percolateUP(self, i):

'''将第i个元素上浮到合适位置'''

while i // 2 > 0:

if self.heapList[i] < self.heapList[i // 2]:

self.heapList[i], self.heapList[

i // 2] = self.heapList[i // 2], self.heapList[i]

else:

break

i = i // 2

def percolateDown(self, i):

'''将第i个元素下沉到合适位置'''

while (2 * i) <= self.currentSize:

minIndex = self.minChild(i)

if self.heapList[i] > self.heapList[minIndex]:

self.heapList[i], self.heapList[

minIndex] = self.heapList[minIndex], self.heapList[i]

else:

break

i = minIndex

def minChild(self, i):

'''返回第i个元素左右子节点中最小值'''

if (2 * i + 1) > self.currentSize:

return 2 * i # 只有一个子节点(左子节点)

elif self.heapList[2 * i] < self.heapList[2 * i + 1]:

return 2 * i

else:

return 2 * i + 1

def insert(self, key):

'''将新元素加入到堆中'''

self.heapList.append(key)

self.currentSize = self.currentSize + 1

self.percolateUP(self.currentSize) # 新值上浮

def findMin(self):

'''返回堆中的最小项，最小项仍保留在堆中'''

return heapList[1]

def delMin(self):

'''返回堆中的最小项，同时从堆中删除'''

result = self.heapList[1]

# 将最后一个元素换到堆顶并删除堆顶元素

self.heapList[1] = self.heapList.pop()

self.currentSize = self.currentSize - 1

self.percolateDown(1) # 将堆顶元素下沉

return result

def isEmpty(self):

'''返回堆是否为空'''

return len(heapList) == 1

def size(self):

'''返回堆中节点的个数'''

return len(heapList) - 1

def printHeap(self):

print(self.heapList[1:])

def buildHeap(self, lst):

'''从一个包含节点的列表里创建新堆,用下沉法将时间复杂度控制在O(n)'''

self.currentSize = len(lst)

i = self.currentSize // 2 #从最后一个节点的父节点开始过滤下沉！

self.heapList = [0] + lst[:]

while i > 0:

self.percolateDown(i)

i = i - 1

self.printHeap()

应用之一-----------------优先队列：

可以在O(1)时间拿到最值，获取最优解，实现对VIP或者进程的优先级等操作

pic_19.png

应用之二-----------------堆排序：