python实现堆

import random #用于测试


class Heap(object):#这是个最小值堆
    def __init__(self,mylist=None):
        self.__size=0
        self.__heaplist=[]
        #两种建堆方式,一种是一个一个插,另一种是直接载入一个列表
        if type(mylist)==type(self.__heaplist):
            self.__heaplist=mylist
            self.__size = len(mylist)
            self.build_heap()

    def is_leaf(self,pos):#因为是完全二叉树,是否是叶子结点很容易写出
        return (pos>=self.__size//2)and(pos<self.__size)

    def left_child(self,pos):
        return 2*pos+1

    def right_child(self,pos):
        return 2*pos+2

    def parent(self,pos):
        return pos//2

    def get_size(self):
        return self.__size

    #这个函数的用法是把某一结点通过沉降达到适合的位置,最小值堆的话比子节点大就下沉
    def shift_down(self,pos):
        while(not self.is_leaf(pos)):
            min_child=self.left_child(pos)
            rc=self.right_child(pos)
            if (rc<self.__size)and(self.__heaplist[rc]<self.__heaplist[min_child]):
                min_child=rc
            if self.__heaplist[pos]<=self.__heaplist[min_child]:
                return
            self.__heaplist[pos],self.__heaplist[min_child]=self.__heaplist[min_child],self.__heaplist[pos]
            pos=min_child
    #这个就是shift_down的逆用法了
    def push_up(self,pos):
        while (pos !=0) and (self.__heaplist[pos]<self.__heaplist[self.parent(pos)]):
            self.__heaplist[pos],self.__heaplist[self.parent(pos)]=self.__heaplist[self.parent(pos)],self.__heaplist[pos]
            pos=self.parent(pos)

    def build_heap(self):
        if self.__size == 0:
            return
        child=self.__size-1
        pnt=self.parent(child)
        for i in range(pnt,-1,-1):#范围是pnt到0的循环
            self.shift_down(i)

    def insert(self,data):
        pos=self.__size
        self.__size+=1
        self.__heaplist.append(data)
        self.push_up(pos)

    def remove_first(self):
        if self.__size ==0:
            return
        self.__heaplist[self.__size-1],self.__heaplist[0]=self.__heaplist[0],self.__heaplist[self.__size-1]
        self.__size-=1
        if(self.__size !=0):
            self.shift_down(0)
        return self.__heaplist.pop()

    def remove_pos(self,pos):
        if self.__size ==0:
            return
        if pos==self.__size-1:
            self.__size-=1
        else:
            self.__heaplist[self.__size - 1], self.__heaplist[pos] = self.__heaplist[pos], self.__heaplist[self.__size - 1]
            self.__size-=1
            #只可能是push_up或者shift_down,又或者不动
            self.push_up(pos)
            if self.__size!=0:
                self.shift_down(pos)
        return self.__heaplist.pop()


list1=list(range(10))
random.shuffle(list1)
print(list1)
#两种建堆
h=Heap(list1)
for i in range(10):
    print(h.remove_first())

for i in range(10):
    h.insert(i)
print(' ')
for i in range(10):
    print(h.remove_first())
#剩下的功能就自己尝试吧

输出:

[4, 5, 6, 8, 0, 2, 7, 1, 9, 3]
0
1
2
3
4
5
6
7
8
9
 
0
1
2
3
4
5
6
7
8
9


### Python 实现排序算法示例 排序是一种基于二叉数据结构的比较型排序算法。该算法分为两步:构建最大和逐步交换根节点与最后一个元素并重新调整。 #### 构建最大 为了使数组满足最大的性质,即父节点总是大于等于子节点,可以使用 `heapify` 函数来维护这一特性: ```python def heapify(arr, n, i): largest = i # Initialize largest as root left = 2 * i + 1 # left child index right = 2 * i + 2 # right child index # Check if left child exists and is greater than root if left < n and arr[i] < arr[left]: largest = left # Check if right child exists and is greater than the current largest if right < n and arr[largest] < arr[right]: largest = right # Change root if needed if largest != i: arr[i], arr[largest] = arr[largest], arr[i] # Swap elements[^4] # Heapify the affected sub-tree recursively heapify(arr, n, largest) ``` #### 执行排序 完成最大之后,可以通过不断移除位于顶端的最大元素,并将其放置到最终位置上;随后减少考虑范围直至整个序列有序化: ```python def heap_sort(arr): n = len(arr) # Build a maxheap. for i in range(n // 2 - 1, -1, -1): heapify(arr, n, i) # One by one extract elements from heap for i in range(n-1, 0, -1): arr[i], arr[0] = arr[0], arr[i] # swap heapify(arr, i, 0) return arr ``` 上述代码展示了完整的排序过程,其中包含了创建初始大顶以及后续迭代过程中保持特性的方法[^5]。 #### 测试实例 这里给出一个简单的测试例子验证实现效果: ```python if __name__ == "__main__": test_array = [12, 11, 13, 5, 6, 7] print("原始数组:", test_array) sorted_array = heap_sort(test_array.copy()) print("排序后的数组:", sorted_array) # 输出应为已排序的结果 ``` 运行此程序将会得到如下输出: ``` 原始数组: [12, 11, 13, 5, 6, 7] 排序后的数组: [5, 6, 7, 11, 12, 13] ```
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值