Python实现堆

Python实现堆

堆

堆是一种完全二叉树(当一个高度为 h 的完美二叉树减少到 h-1，并且最底层的槽被毫无间隙地从左到右填充，我们就叫它完全二叉树)，有最大堆和最小堆两种

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

堆的表示

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

parent = int((i-1) / 2)    # 取整
left = 2 * i + 1
right = 2 * i + 2

最大堆

class Array(object):
    def __init__(self, size=32, init=None):
        self._size = size
        self._items = [init] * self._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(len(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")
        # 把值插入最后一位
        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)
            # 如果插入的值大于 parent，一直交换
            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):
        """
        获取并且移除根节点
        :return:
        """
        if self._count <= 0:
            raise Exception("empty")
        # 保存root节点
        value = self._elements[0]
        self._count -= 1
        # 最右下的节点放到root后siftDown
        self._elements[0] = self._elements[self._count]
        # 维持堆特性
        self._siftdown(0)
        return value

    def _siftdown(self, ndx):
        # 下筛选操作
        left = 2 * ndx + 1
        right = 2 * ndx + 2
        # 确定哪个节点包含较大的值
        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 heapsort_reverse(alist):
    length = len(alist)
    maxheap = MaxHeap(length)
    for i in alist:
        maxheap.add(i)
    res = []
    for i in range(length):
        res.append(maxheap.extract())
    return res