python堆的实现以及堆的排序

class Heap:

    def __init__(self, n):
        self.item = [None for i in range(0, n + 1)]
        self.N = 0
        self.MAX = n

    def _compare(self, i, j):
        return self.item[i] < self.item[j]

    def _exch(self, i, j):
        self.item[i], self.item[j] = self.item[j], self.item[i]

    def insert(self, value):
        # 往堆中插入
        if self.N == self.MAX:
            return -1
        self.N += 1
        self.item[self.N] = value
        self._swim(self.N)

    def _swim(self, n):
        # 堆的上浮
        if n == 1:
            return
        if self._compare(temp := int(n / 2), n):
            self._exch(temp, n)
        else:
            return
        self._swim(temp)

    def del_max(self):
        # 删除堆的最大节点
        self._exch(n := 1, self.N)
        self.item[self.N] = None
        self.N -= 1
        self._sink(2 * n, n)

    def _sink(self, n, temp):
        if n + 1 > self.N:
            return
        if self.item[n + 1] is None:
            if self._compare(temp, n):
                self._exch(temp, n)
            return

        if self._compare(n, n + 1):
            if self._compare(temp, n + 1):
                self._exch(temp, n := n + 1)
        else:
            if self._compare(temp, n):
                self._exch(temp, n)
        self._sink(2 * n, n)


class HeapSort(Heap):

    def __init__(self, item, n=0):
        super().__init__(n)
        self.item = item
        self.N = len(item)
        self.n = self.N - 1
        self._to_heap(int(self.N / 2))

    def _to_heap(self, n):
        # 将数组转换为堆
        if n == 0:
            return
        self._sink_(2 * n - 1, n - 1, self.N)
        self._to_heap(n - 1)

    def _sink_(self, n, temp, end):
        # 堆的下沉
        if n >= end:
            return
        if n + 1 == end:
            if self._compare(temp, n):
                self._exch(temp, n)
            return
        if self._compare(n, n + 1):
            if self._compare(temp, n + 1):
                self._exch(temp, n := n + 1)
        else:
            if self._compare(temp, n):
                self._exch(temp, n)
        self._sink_(2 * n + 1, n, end)

    def sort(self):
        # 堆的排序
        if self.n <= 0:
            self.n = self.N
            return
        self._exch(n := 0, self.n)
        self._sink_(2 * n + 1, n, self.n)
        self.n -= 1
        self.sort()


if __name__ == '__main__':
    # heap = Heap(10)
    # heap.insert(1)
    # heap.insert(3)
    # heap.insert(2)
    # heap.insert(6)
    # heap.insert(5)
    # heap.insert(9)
    # heap.insert(6)
    # heap.insert(5)
    #
    # heap.del_max()
    # heap.del_max()
    # heap.del_max()
    # heap.del_max()
    # heap.del_max()
    # heap.del_max()
    # heap.del_max()
    # heap.del_max()

    string = [5, 3, 1, 2, 7, 4, 6, 0, 9, 12, 123]
    heap = HeapSort(string)
    print(heap.item)
    heap.sort()
    print(heap.item)