Python

二叉堆(binary heap)

二叉堆是一种特殊的堆，二叉堆是完全二叉树或者是近似完全二叉树。二叉堆满足堆特性：父节点的键值总是保持固定的序关系于任何一个子节点的键值，且每个节点的左子树和右子树都是一个二叉堆。

当父节点的键值总是大于或等于任何一个子节点的键值时为最大堆。 当父节点的键值总是小于或等于任何一个子节点的键值时为最小堆。

二叉堆的存储

二叉堆一般用数组来表示。如果根节点在数组中的位置是1，第n个位置的子节点分别在2n和 2n+1。因此，第1个位置的子节点在2和3，第2个位置的子节点在4和5。以此类推。这种基于1的数组存储方式便于寻找父节点和子节点。

如果存储数组的下标基于0，那么下标为i的节点的子节点是2i + 1与2i + 2；其父节点的下标是?floor((i ? 1) ∕ 2)?, 函数floor(x), 其功能是“向下取整”，或者说“向下舍入”，即取不大于x的最大整数(与“四舍五入”不同，下取整是直接取按照数轴上最接近要求值的左边值，即不大于要求值的最大的那个值)。比如floor(1.1),floor(1.9)都是返回1。

如下图的两个堆：

将这两个堆保存在以1开始的数组中：

位置: 1 2 3 4 5 6 7 8 9 10 11

左图: 1 2 3 4 5 6 7 8 9 10 11

右图: 11 9 10 5 6 7 8 1 2 3 4

对于一个很大的堆，这种存储是低效的。因为节点的子节点很可能在另外一个内存页中。B-heap是一种效率更高的存储方式，把每个子树放到同一内存页。

如果用指针链表存储堆，那么需要能访问叶节点的方法。可以对二叉树“穿线”(threading)方式，来依序遍历这些节点。

基本操作

插入节点

在数组的最末尾插入新节点。然后自下而上调整子节点与父节点(称作up-heap或bubble-up, percolate-up, sift-up, trickle up, heapify-up, cascade-up操作)：比较当前节点与父节点，不满足堆性质则交换。从而使得当前子树满足二叉堆的性质。时间复杂度为O(log n)。

删除节点

删除根节点用于堆排序。

对于最大堆，删除根节点就是删除最大值；对于最小堆，是删除最小值。然后，把堆存储的最后那个节点移到填在根节点处。再从上而下调整父节点与它的子节点：对于最大堆，父节点如果小于具有最大值的子节点，则交换二者。这一操作称作down-heap或bubble-down, percolate-down, sift-down, trickle down, heapify-down, cascade-down,extract-min/max等。直至当前节点与它的子节点满足堆性质为止。

构造二叉堆

一个直观办法是从单节点的二叉堆开始，每次插入一个节点。其时间复杂度为 {\displaystyle O(n\log n)} O(n\log n)。

最优算法是从一个节点元素任意放置的二叉树开始，自底向上对每一个子树执行删除根节点时的Max-Heapify算法(这是对最大堆而言)使得当前子树成为一个二叉堆。具体而言，假设高度为h的子树均已完成二叉堆化，那么对于高度为h+1的子树，把其根节点沿着最大子节点的分枝做调整，最多需要h步完成二叉堆化。可以证明，这个算法的时间复杂度为O(n)。

代码

#!/usr/bin/env python2

# -*- coding: utf-8 -*-

"""

@author: gsharp

"""

class BinaryHeap:

def __init__(self, n):

self.heap = [0] * n

self.size = 0

def remove_min(self):

removed = self.heap[0]

self.size -= 1

self.heap[0] = self.heap[self.size]

self._down(0)

return removed

def add(self, value):

self.heap[self.size] = value

self._up(self.size)

self.size += 1

def _up(self, pos):

while pos > 0:

parent = (pos - 1) // 2

if self.heap[pos] >= self.heap[parent]:

break

self.heap[pos], self.heap[parent] = self.heap[parent], self.heap[pos]

pos = parent

def _down(self, pos):

while True:

child = 2 * pos + 1

if child >= self.size:

break

if child + 1 < self.size and self.heap[child + 1] < self.heap[child]:

child += 1

if self.heap[pos] <= self.heap[child]:

break

self.heap[pos], self.heap[child] = self.heap[child], self.heap[pos]

pos = child

def test():

h = BinaryHeap(10)

h.add(5)

h.add(7)

h.add(9)

h.add(4)

h.add(3)

print(h.heap)

h.add(1)

print(h.heap)

h.add(2)

print(h.heap)

print(h.remove_min())

print(h.remove_min())

print(h.remove_min())

test()