Data structure and algorithm Python to achieve heap and heap sort

What is a heap?
Heap is a complete binary tree

• Maximum heap: For each non-leaf node, it is larger than its two children, which is called the maximum heap feature, and the root node in the largest heap is often the maximum
• Minimal heap: In contrast to the largest heap, each non-leaf node has two children larger than him
  . Representation of heap: Represented by a binary tree.
  Heap provides a very limited number of operations
  . 1. Insert new values. Insertion is more troublesome. To maintain the right characteristics, the sift_up operation is required
  . 2. Get and remove the value of the root node. Each time we can get the maximum and minimum values. At this time, we need to replace the rightmost node value of the bottom layer with the siftdown operation after root.

#实现一个定长的数组arroy
class Array(object):
    #初始化
    def __init__(self,size = 32):
        #
        self._size = size
        #长度为size，value全为None的列表
        self._items = [None] * size

    #通过[]获取value
    def __getitem__(self,index):
        return self.items[index]

    #下标赋值
    def __setitem__(self,index,value):
        self._items[index] = value
    #返回长度
    def __len__(self):
        return self._size
    #清除数组
    def cleor(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._count = 0
        #新建一个数组
        self._elements = Array(maxsize)
    #长度
    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
        #调用silfup方法
        self.silfup(self._count - 1)
    #判断位置方法
    def _silfup(self, ndx):
        #判断换长度
        if ndx > 0 :
            #计算上一个节点的下标
            parent = ((ndx-1) / 2)
            #判断子节点大于父节点
            if self._elements[ndx] > self._elements[parent]:
                #交换值
                self._elements[ndx],self._elements[parent] = self._elements[parent],self._elements[ndx]
                #递归在进行比较
                self._silfup(parent)

    #删除根节点
    def extract(self):
        #先判断是否还有值
        if self._count <= 0:

            raise Exception('empty')
        #取出根节点
        value = self._elements[0]
        #长度减一
        self._count -= 1
        #把最后一个节点上的值，赋值给根节点
        self._elements[0] = self._elements[self._count]
        #调用_siftdown 函数
        self._siftdown(0)
        #返回根节点的值
        return value

    #通过siftdown的方法满足最大堆的特点
    def _siftdown(self,ndx):
        #计算左孩子的下标
        left = 2 * ndx + 1
        #3计算右孩子的下标
        right = 2 * ndx + 2
        langest = ndx

        #首先左节点下标要小于当前的数组的长度，其次左孩子大于根节点，再其次左孩子大于右孩子
        if (left < self._count and
                self._elements[left] >= self._elements[langest] and
                self._elements[left] >= self._elements[right]):
            #把值左孩子的下标，赋值给langest
            langest = left
        #右孩子下标小于数组的长度，其次右孩子大于左孩子
        elif right < self._count and self._elements[right] >= self._elements[langest]:
            #把右孩子的下标赋给langest
            langest = right
        #当左孩子，或者是右孩子的不等于根下标
        if langest != ndx:
            #根节点和左孩子或者右孩子交换位置
            self._elements[ndx],self._elements[langest] = self._elements[langest],self._elements[ndx]
            #递归调用siftdown方法，，从当前节点开始重新判断
            self._siftdown(langest)