什么是堆

堆是一种完全二叉树，有最大堆和最小堆两种

1.最大堆:对于每个非叶子节点V， V的值都比它的两个孩子大，称为 最大堆特性(heap order property)最大堆里的根总是存储最大值, 最小的值存储在叶节点
2.最小堆:和最大堆相反，每个非叶子节点V，V的两个孩子的值都比它大

关于堆的操作

堆提供了很有限的几个操作:

1.插入新的值。插入比较麻烦的就是需要维持堆的特性。需要sift-up操作，具体在代码中实现
2.获取并移除根节点的值。每次我们都可以获取最大值或最小值。这个时候需要把底层最右边的节点值替换到root节点之后执行sift-down操作

堆的表示

这里用数组实现堆

仔细观察下，因为完全二叉树的特性，树不会有间隙。对于数组里的一个下标 i ,我们可以得到它的父亲和孩子的节点对应的下标：

parent = int( (i-1) / 2 ) #取整
left = 2 * i +1
right = 2 * i + 2
超出下标表示没有对应的孩子节点

代码实现

关于add()方法的实现原理

关于siftup()递归操作的原理图

关于extract()方法的原理图

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

####################################
    # heap 实现
####################################

class Array(object):
    def __init__(self,size=32):
        self._size = size
        self._items = [None] * size

    def __getitem__(self,index):
        return self._items[index]

    def __setitem__(self,index,value):
        self._items[index] = value

    def __len__(self):
        return self._size

    def clear(self,value=None):
        for i in range(self._items):
            self._items[i] = value

    def __iter__(self):
        for item in self._items:
            yield item


'''
    初始化堆结构
'''
class MaxHeap(object):
    def __init__(self,maxsize=None):
        self.maxsize = maxsize
        self._elements = Array(maxsize)
        self._count = 0

    def __len__(self):
        return self._count

    def add(self,value):
        if self._count >= self.maxsize:
            raise Exception('full')
        #将插入的值value给数组最后一值
        self._elements[self._count] = value
        #堆的容量加一
        self._count += 1
        self._siftup(self._count-1)

    def _siftup(self,ndx):      #递归交换直到满足最大堆特性
        if ndx > 0:
            #获取添加节点的父节点的下标值
            parent = int((ndx-1)/2)
            #如果添加节点的值大于父节点的值
            if self._elements[ndx] > self._elements[parent]:
                self._elements[ndx],self._elements[parent] = self._elements[parent],self._elements[ndx]
                self._siftup(parent)




    def extract(self):
        if self._count <= 0:
            raise Exception('empty')
        #获取根节点的值
        value = self._elements[0]
        #将堆最后一个叶子节点作为root节点
        self._elements[0] = self._elements[self._count]
        self._siftdown(0)
        return value

    def _siftdown(self,ndx):
        #获取左右孩子节点的下标
        left = 2 * ndx + 1
        right = 2 * ndx + 2
        #默认ndx为最大
        largest = ndx

        if(left < self._count and   #有左孩子
            self._elements[left] >= self._elements[largest] and
            self._elements[left] >= self._elements[right]):     #左孩子 > 右孩子
            largest = left

        elif right < self._count and self._elements[right] >= self._elements[largest]:
            largest = right

        if largest != ndx:
            self._elements[ndx],self._elements[largest] = self._elements[largest],self._elements[ndx]
            self._siftdown(largest)

def test_max_heap():
    import random
    n = 5
    h = MaxHeap(n)
    for i in range(n):
        h.add(i)
    for i in reversed(range(n)):
        assert i == h.extract()



'''
    实现堆排序
    上面我们实现了最大堆，每次我们都能extract一个最大的元素了，于是一个倒序排序函数就能很容易写出来了:
'''
def heapsort_reverse(array):
    length = len(array)
    maxheap = MaxHeap(length)
    for i in array:
        maxheap.add(i)
    res = []
    for i in range(length):
        res.append(maxheap.extract())
    return res


def test_heapsort_reverse():
    import random
    l = list(range(10))
    random.shuffle(1)
    assert heapsort_reverse(l) == sorted(l,reverse=True)

关于 python 里的 heapq

python 其实自带了 heapq 模块,用来实现堆的相关操作，原理是类似的，可以阅读相关文档

练习

1.尝试实现一个最小堆
2.我们实现的堆排序是inplace的吗，如果不是，你能改成inplace的吗?
3.这里我们用最大堆实现了一个heapsort_reverse函数,请你实现一个正序排序的函数.似乎不止一种方式