堆排序的比较次数_python实现·十大排序算法之堆排序(Heap Sort)

83ca5bd5a165ce9a181ef9315ef882e2.png

简介

堆排序(Heap Sort)是利用堆这种数据结构而设计的一种排序算法,是一种选择排序。
堆是具有以下性质的完全二叉树:每个结点的值都大于或等于其左右孩子结点的值,称为大顶堆;或者每个结点的值都小于或等于其左右孩子结点的值,称为小顶堆。
堆排序思路为: 将一个无序序列调整为一个堆,就能找出序列中的最大值(或最小值),然后将找出的这个元素与末尾元素交换,这样有序序列元素就增加一个,无序序列元素就减少一个,对新的无序序列重复操作,从而实现排序。

算法实现步骤

  1. 构造初始堆。将给定无序序列构造成一个大顶堆(一般升序采用大顶堆,降序采用小顶堆);
  2. 将堆顶元素与末尾元素进行交换,使末尾元素最大。然后继续调整堆,再将堆顶元素与末尾元素交换,得到第二大元素;
  3. 重新调整结构,使其满足堆定义,然后继续交换堆顶元素与当前末尾元素;
  4. 如此反复进行交换、重建、交换,直到整个序列有序。

Python 代码实现

# heap_sort 代码实现

def build(arr:List[int], root, end):
    while True:
        child = 2 * root + 1 # 左子节点的位置
        if child > end: # 若左子节点超过了最后一个节点,则终止循环
            break
        if (child + 1 <= end) and (arr[child + 1] > arr[child]): # 若右子节点在最后一个节点之前,并且右子节点比左子节点大,则我们的孩子指针移到右子节点上
            child += 1
        if arr[child] > arr[root]: # 若最大的孩子节点大于根节点,则交换两者顺序,并且将根节点指针,移到这个孩子节点上
            arr[child], arr[root] = arr[root], arr[child]
            root = child
        else:
            break

def heap_sort(arr:List[int]):
    n = len(arr)
    first_root = n // 2 - 1 # 确认最深最后的那个根节点的位置
    for root in range(first_root, -1, -1): # 由后向前遍历所有的根节点,建堆并进行调整
        build(arr, root, n - 1)
        
    for end in range(n - 1, 0, -1): # 调整完成后,将堆顶的根节点与堆内最后一个元素调换位置,此时为数组中最大的元素,然后重新调整堆,将最大的元素冒到堆顶。依次重复上述操作
        arr[0], arr[end] = arr[end], arr[0]
        build(arr, 0, end - 1)

# 测试数据
if __name__ == '__main__':
    import random
    random.seed(54)
    arr = [random.randint(0,100) for _ in range(10)]
    print("原始数据:", arr)
    heap_sort(arr)
    print("堆排序结果:", arr)

# 输出结果

原始数据: [17, 56, 71, 38, 61, 62, 48, 28, 57, 42]
堆排序结果: [17, 28, 38, 42, 48, 56, 57, 61, 62, 71]

动画演示

d00aa04c310baa61c8700db982e4195c.gif
堆排序动画演示

算法分析

  • 时间复杂度
    在每次重建时,随着堆的容量的减小,层数会下降,函数时间复杂度会变化。重建堆一共需要n-1次循环,每次循环的比较次数为
    equation?tex=%5Clog+_2i,则相加为:
    equation?tex=T%3D%5Clog+_2n%2B%5Clog+_2%28n-1%29%2B%5Ccdots+%2B%5Clog+_23%2B%5Clog+_22%3D%5Clog+_2%5Cleft%28+n%21+%5Cright%29+%5C%5C
    equation?tex=%5Cbecause+%5Cleft%28+%5Cdfrac%7Bn%7D%7B2%7D+%5Cright%29+%5E%7B%5Cdfrac%7Bn%7D%7B2%7D%7D%5Cle+n%21%5Cle+n%5En+%5C%5C
    equation?tex=%5Ctherefore+%5Cdfrac%7Bn%7D%7B2%7D%5Clog+_2%5Cleft%28+%5Cdfrac%7Bn%7D%7B2%7D+%5Cright%29%5Cle+%5Clog+_2%5Cleft%28+n%21+%5Cright%29+%5Cle+n%5Clog+_2n+%5C%5C

    所以堆排序时间复杂度为
    equation?tex=O%28nlog_2n%29
  • 空间复杂度
    空间复杂度就是在交换元素时那个临时变量所占的内存空间,所以堆排序空间复杂度为
    equation?tex=O%281%29
  • 稳定性
    堆排序在交换数据的时候,是比较父结点和子节点之间的数据,所以,即便是存在两个数值相等的兄弟节点,它们的相对顺序在排序也可能发生变化。因此,堆排序是不稳定的。
  • 综合评价

c05a76cca28ac51bf97e5e893bab0307.png

联系我们

个人博客网站:

首页_bling博客系统​www.bling2.cn
e186f2e238ed846f0ead23f17784706f.png

Github地址:

https://github.com/lb971216008/Use-Python-to-Achieve​github.com

知乎专栏:

Python实现​zhuanlan.zhihu.com
70d0235bc85b6e2900700bb04cae2e7b.png

小专栏:

Python实现 - 小专栏​xiaozhuanlan.com
70d0235bc85b6e2900700bb04cae2e7b.png

是否专栏:

人类身份验证 - SegmentFault​segmentfault.com

876701c0e0e578cbe6be8c92ee9c1ebf.gif
扫码关注微信公众号【不灵兔】,获取更多资料
  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
1. 树状大根堆 树状大根堆是一种二叉树,满足以下性质: 1. 每个节点的值都大于等于其子节点的值。 2. 树的最后一层节点都靠左排列。 在Python中,我们可以使用列表来表示二叉树,其中第i个元素的左子节点为2i,右子节点为2i+1,父节点为i//2。 以下是创建树状大根堆的代码: ```python class MaxHeap: def __init__(self, arr=None): self.heap = [0] if arr: self.heap.extend(arr) self._build_heap() def _build_heap(self): n = len(self.heap) - 1 for i in range(n // 2, 0, -1): self._heapify(i) def _heapify(self, i): n = len(self.heap) - 1 largest = i left = 2 * i right = 2 * i + 1 if left <= n and self.heap[left] > self.heap[largest]: largest = left if right <= n and self.heap[right] > self.heap[largest]: largest = right if largest != i: self.heap[i], self.heap[largest] = self.heap[largest], self.heap[i] self._heapify(largest) def push(self, val): self.heap.append(val) i = len(self.heap) - 1 while i > 1 and self.heap[i] > self.heap[i // 2]: self.heap[i], self.heap[i // 2] = self.heap[i // 2], self.heap[i] i //= 2 def pop(self): if len(self.heap) == 1: return None if len(self.heap) == 2: return self.heap.pop() root = self.heap[1] self.heap[1] = self.heap.pop() self._heapify(1) return root ``` 2. 堆排序 堆排序是一种排序算法,基于树状大根堆实现。其思路是先将数组构建成树状大根堆,然后将堆顶元素与最后一个元素交换,再将前面的元素重新构建成树状大根堆,重复此过程直到数组有序。 以下是堆排序的代码: ```python def heap_sort(arr): n = len(arr) heap = [0] + arr for i in range(n // 2, 0, -1): _heapify(heap, i, n) for i in range(n, 0, -1): heap[1], heap[i] = heap[i], heap[1] _heapify(heap, 1, i - 1) return heap[1:] def _heapify(heap, i, n): largest = i left = 2 * i right = 2 * i + 1 if left <= n and heap[left] > heap[largest]: largest = left if right <= n and heap[right] > heap[largest]: largest = right if largest != i: heap[i], heap[largest] = heap[largest], heap[i] _heapify(heap, largest, n) ``` 3. 取前k个值 在树状大根堆中,堆顶元素是最大的元素,可以通过不断取出堆顶元素来获得最大的k个元素。 以下是取前k个值的代码: ```python def top_k(arr, k): n = len(arr) heap = [0] + arr[:k] for i in range(k // 2, 0, -1): _heapify(heap, i, k) for i in range(k, n): if arr[i] > heap[1]: heap[1] = arr[i] _heapify(heap, 1, k) return heap[1:] ``` 以上是树状大根堆、堆排序和取前k个值的Python实现

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值