最大堆和堆排序的Python实现

最新推荐文章于 2026-02-25 00:52:51 发布

原创最新推荐文章于 2026-02-25 00:52:51 发布 · 572 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

收录于

Python数据结构与算法

本文详细介绍了完全二叉树的概念，区分了满二叉树与完全二叉树的区别，阐述了大顶堆和小顶堆的定义，并通过Python代码实现了最大堆的构建过程，包括添加元素和提取根节点的操作。最后，展示了如何利用最大堆实现堆排序。

堆的表示

堆排序

完整代码

引用其他博客大神的介绍:

"首先，什么是满？满二叉树？字面意思，满就是全部都有，每个结点都有两个孩子！满二叉树就是整整齐齐一家人，整齐的金字塔形状【靠脑补吧。。】为啥说完全二叉树是满二叉树那边来的？完全二叉树是这样的二叉树：

①完全二叉树的倒数第二行及之前的行，都与满二叉树相同。

②倒数第一行右半部分可以是空的，也可以是满的，但不能有单个的出现！

③倒数第一行左半部分可以是空的，也可以是满的，也可有单个的出现，但有且只能有一个单个，且必须是它父亲的左孩子！"

那么，在完全二叉树的基础上，满足以下任意条件的就是堆：

1.每个节点的值都大于或等于其左右子节点的值，称为大顶堆。

2.每个节点的值都小于或等于其左右子节点的值，称为小顶堆。

堆的表示

用数组来实现堆，实现一个最大堆，首先，还是跟以前一样，定义一个最大堆的类，然后，初始化它的最大长度，和导入数组，计算长度等量。

class MaxHeap(object):

    def __init__(self, maxsize=None):
        self.maxsize = maxsize
        self._elements = Array(maxsize)
        self._count = 0

    def __len__(self):
        return self._count

接着，定义添加操作，将值加入到数组当中，每插入一个，就让计数加一。但要注意要保持最大堆的特性，就是保持每个分叶节点小于其父节点的值（即siftup操作完成的功能）。

    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)  # 维持堆的特性

siftup,维持最大堆的特性，不断去拿新插入点的与它的父亲节点交换，如果比它父亲大，就一直交换。

    def _siftup(self, ndx):
        if ndx > 0:
            parent = int((ndx-1)/2) #父亲节点的位置
            if self._elements[ndx] > self._elements[parent]:    # 如果插入的值大于 parent，一直交换
                self._elements[ndx], self._elements[parent] = self._elements[parent], self._elements[ndx]
                self._siftup(parent)    # 递归

获取并且移除根节点的值

每一次根节点的值是最大的，每一次通过把这个（是堆排序中需要的一个操作）

先把根节点给保留到一个value值当中，然后，将最后一个元素放到根节点的位置，再进行siftdown操作。

这里的siftdown函数也跟siftup函数类似，都是为了保持最大堆的特性，唯一不同的是，siftdown是从上往下进行遍历，开始，进行取值放值。

    def extract(self):
        if self._count <= 0:
            raise Exception('empty')
        value = self._elements[0]    # 保存 root 值
        self._count -= 1
        self._elements[0] = self._elements[self._count]    # 最右下的节点放到root后siftDown
        self._siftdown(0)    # 维持堆特性
        return value

siftdown,这个操作比较麻烦，不断跟孩子进行交换，满足最大堆的特性。先获取了在数组中，左、右孩子相对于根节点的位置，然后，再定义一个最大值，将ndx作为初始值开始遍历，接下来就是判断一下，跟那些孩子进行交换，首先（第一个if），判断它有没有左孩子（超出下标就认为是没有左孩子的，并且左孩子的值要比当前的这个值大，并且，左孩子比右孩子大），那么，就把左孩子的值赋给最大值；下面（elif），如果有右孩子，而且，右孩子的值比最大的大，那么就把最大值赋成右孩子的值。

最后（第二个if）如果跟ndx不一样就交换，使ndx位置上的值始终是最大值。如此反复递归。直到所有父亲大于其孩子的值。

    def _siftdown(self, ndx):
        left = 2 * ndx + 1  #左孩子的位置
        right = 2 * ndx + 2 #右孩子的位置
        # determine which node contains the larger value
        largest = ndx
        if (left < self._count and     # 有左孩子
                self._elements[left] >= self._elements[largest] and
                self._elements[left] >= self._elements[right]):  # 原书这个地方没写实际上找的未必是largest
            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)

上面是实现的最大堆，那堆排序如何实现呢？

堆排序

其实，只要最大堆找到了，就可以了，构造好最大堆之后，每次用（.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

PS:python自带的heapq可以实现堆排列！

完整代码

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

# 第二章拷贝的 Array 代码


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(len(self._items)):
            self._items[i] = value

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

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


class MaxHeap(object):
    """
    Heaps:
    完全二叉树，最大堆的非叶子节点的值都比孩子大，最小堆的非叶子结点的值都比孩子小
    Heap包含两个属性，order property 和 shape property(a complete binary tree)，在插入
    一个新节点的时候，始终要保持这两个属性
    插入操作：保持堆属性和完全二叉树属性, sift-up 操作维持堆属性
    extract操作：只获取根节点数据，并把树最底层最右节点copy到根节点后，sift-down操作维持堆属性

    用数组实现heap，从根节点开始，从上往下从左到右给每个节点编号，则根据完全二叉树的
    性质，给定一个节点i， 其父亲和孩子节点的编号分别是:
        parent = (i-1) // 2
        left = 2 * i + 1
        rgiht = 2 * i + 2
    使用数组实现堆一方面效率更高，节省树节点的内存占用，一方面还可以避免复杂的指针操作，减少
    调试难度。

    """

    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)
            if self._elements[ndx] > self._elements[parent]:    # 如果插入的值大于 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._count -= 1
        self._elements[0] = self._elements[self._count]    # 最右下的节点放到root后siftDown
        self._siftdown(0)    # 维持堆特性
        return value

    def _siftdown(self, ndx):
        left = 2 * ndx + 1
        right = 2 * ndx + 2
        # determine which node contains the larger value
        largest = ndx
        if (left < self._count and     # 有左孩子
                self._elements[left] >= self._elements[largest] and
                self._elements[left] >= self._elements[right]):  # 原书这个地方没写实际上找的未必是largest
            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_maxheap():
    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()


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(l)
    assert heapsort_reverse(l) == sorted(l, reverse=True)


def heapsort_use_heapq(iterable):
    from heapq import heappush, heappop
    items = []
    for value in iterable:
        heappush(items, value)
    return [heappop(items) for i in range(len(items))]


def test_heapsort_use_heapq():
    import random
    l = list(range(10))
    random.shuffle(l)
    assert heapsort_use_heapq(l) == sorted(l)

标签

#Pthon数据结构与算法