【python3数据结构】堆heap

# -*- coding: utf-8 -*-
# @Date   : 2019/11/29
# @File   : myHeap.py


class PriorityQueueBase(object):

    class Item:

        __slots__ = ['_key', '_value']

        def __init__(self, k, v):
            self._key = k
            self._value = v

        def __lt__(self, other):
            return self._key < other._key

        def is_empty(self):
            return len(self) == 0

        def __str__(self): # print(对象) 打印出来的东西
            return str(self._key)


class Heap(PriorityQueueBase):
    '''Min-Heap'''
    def __init__(self):
        self._data = []

    def __len__(self):
        return len(self._data)

    def is_empty(self):
        return len(self) == 0

    def add(self, key, value):
        self._data.append(self.Item(k=key, v=value))
        self._upheap(len(self._data) - 1) # 上升法

    def min(self):
        item = self._data[0]
        return (item._key, item._value)

    def remove_min(self):
        # 最后一个节点来替换第一个最小值节点
        self._swap(0, len(self._data)-1)
        item = self._data.pop()
        self._downheap(0) # 对替换的节点进行下沉
        return (item._key, item._value)

    # 父节点index
    def _parent(self, j):
        return (j - 1) // 2
    # 左儿子index
    def _left(self, j):
        return 2 * j + 1
    # 右儿子index
    def _right(self, j):
        return 2 * j + 2
    # 交换节点
    def _swap(self, i, j):
        self._data[i], self._data[j] = self._data[j], self._data[i]

    # j节点的左儿子是否存在 index是否小于data长度
    def _has_left(self, j):
        return self._left(j) < len(self._data)

    def _has_right(self, j):
        return self._right(j) < len(self._data)

    def _upheap(self, j):
        parent = self._parent(j) # 父亲节点
        if j > 0 and self._data[parent] > self._data[j]:
            self._swap(j, parent)
            self._upheap(parent)

    def _downheap(self, j):
        # j 当前节点
        if self._has_left(j):
            left = self._left(j)
            small_child = left
            if self._has_right(j):
                right = self._right(j)
                if self._data[left] > self._data[right]:
                    small_child = right
            if self._data[small_child] < self._data[j]:
                self._swap(small_child, j)
                self._downheap(small_child)


if __name__ == '__main__':

    heap = Heap()
    heap.add(4, "D")
    heap.add(3, "C")
    heap.add(1, "A")
    heap.add(5, "E")
    heap.add(2, "B")
    heap.add(7, "G")
    heap.add(6, "F")
    heap.add(26, "Z")
    # heap.add(1, "Z")

    # print(heap)

    for item in heap._data:
        print(item)


    print(heap.remove_min())
    print(heap.min())
    print()
    print(heap.remove_min())
    print(heap.min())
    print()
    print(heap.remove_min())
    print(heap.min())
    print()
    print(heap.remove_min())
    print(heap.min())