浅析经典排序算法之堆排序

开发 前端 算法
堆通常是一个可以被看做一棵树(完全)的数组对象。

堆通常是一个可以被看做一棵树(完全)的数组对象。且总是满足以下规则:

堆是一棵完全二叉树

节点总是大于(或小于)它的孩子节点。

因此,根据第二个特性,就把二叉堆分为大顶堆(或叫最大堆),和小顶堆(或叫最小堆)。

在上图中,1 2 是大顶堆 ,3 4 是小顶堆。判断是不是堆的条件:「从根结点到任意结点路径上结点序列的有序性!大顶堆和小顶堆判断序列是顺序还是逆序!」

Python并没有提供“堆”这种数据类型,它是直接把列表当成堆处理的。Python提供的heapq包中有一些函数,提供执行堆操作的工具函数

>>> import heapq 
>>> heapq.__all__ 
['heappush''heappop''heapify''heapreplace''merge''nlargest''nsmallest''heappushpop'
  • 1.
  • 2.
  • 3.

堆排序

往堆中插入一个元素后,我们就需要进行调整,让其重新满足堆的特性,这个过程叫做堆化(heapify)。

那么堆排序的基本思路是怎么样的呢?

  1. 将待排序序列构建成一个堆 H[0……n-1],根据(升序降序需求)选择大顶堆或小顶堆;
  2. 把堆首(最大值)和堆尾互换;
  3. 顺着节点所在的路径,向上或者向下,对比,然后交换,目的是把新的数组顶端数据调整到相应位置;

下面举个例子(资源来自王争算法),比如在上面的大顶堆中添加数据22。


堆化非常简单,就是顺着节点所在的路径,向上或者向下,对比,然后交换。

堆排序的删除操作,这里一般指的是堆顶元素,当我们删除堆顶元素之后,就需要把第二大的元素放到堆顶,那第二大元素肯定会出现在左右子节点中。

然后我们再迭代地删除第二大节点,以此类推,直到叶子节点被删除。但是这样会产生一个数组空洞的问题。


因此,这里面又个技巧,就是删除堆顶元素的时候,不能直接删除,要用堆顶元素和最后一个元素做交换,然后根据堆的特点调整堆,直到满足条件。

排序的过程就是每次待排序的序列长度减去1再执行这两步。

下面给出通过Python中的heapq模块实现的堆排序简单代码。

from heapq import heappop, heappush 
 
def heap_sort(array): 
    heap = [] 
    for element in array: 
        heappush(heap, element) 
 
    ordered = [] 
 
    while heap: 
        ordered.append(heappop(heap)) 
    return ordered 
 
array = [13, 21, 15, 5, 26, 4, 17, 18, 24, 2] 
print(heap_sort(array)) 
# [2, 4, 5, 13, 15, 17, 18, 21, 24, 26] 
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.

如果不使用heapq模块,对于推排序需要了解堆排序中的建堆过程。

将数组原地建成一个堆。不借助另一个数组,就在原数组上操作。建堆的过程,有两种思路。

第一种建堆思路的处理过程是从前往后处理数组数据,并且每个数据插入堆中时,都是从下往上堆化。而第二种实现思路,是从后往前处理数组,并且每个数据都是从上往下堆化。


  • 补充:利用层序遍历(遍历方式还有前中后)映射到数组后,假设树或子树的根节点为arr[root],则其对应的子节点分别为arr[root*2+1],arr[root*2+2]。

也就是如果节点的下标是 i,那左子节点的下标就是 2∗i+1,右子节点的下标就是 2∗i+2,父节点的下标就是 。

def heap_sort(array): 
    n = len(array) 
    # 从尾部开始建堆,这样保证子节点有序 
    for i in range((n-1)//2, -1, -1): 
        _shift(array, n, i) 
    # 依次把堆顶元素交换到最后,重建堆顶(堆不包含刚交换的最大元素) 
    for i in range(n-1, 0, -1): 
        array[0], array[i] = array[i], array[0] 
        _shift(array, i, 0) 
    return array 
 
# 重建堆顶元素 n:堆元素个数,i:堆建顶位置 
def _shift(array, n, i): 
    # 如果没有子节点,直接返回 
    if i*2+1 >= n: 
        return 
    # 取最大子节点位置 
    maxsub = i*2+2 if i*2+2 < n and array[i*2+1] <= array[i*2+2] else i*2+1 
    # 如果节点小于最大子节点,交换元素,递归以子节点为堆顶重建 
    if array[i] < array[maxsub]: 
        array[i], array[maxsub] = array[maxsub], array[i] 
        _shift(array, n, maxsub) 
 
if __name__ == '__main__'
    array = [13, 21, 15, 5, 26, 4, 17, 18, 24, 2] 
    print(heap_sort(array)) 
     
# [2, 4, 5, 13, 15, 17, 18, 21, 24, 26] 
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
  • 23.
  • 24.
  • 25.
  • 26.
  • 27.
  • 28.

堆排序不是稳定的排序算法,因为在排序的过程,存在将堆的最后一个节点跟堆顶节点互换的操作,所以就有可能改变值相同数据的原始相对顺序。堆排序整体的时间复杂度是O(nlogn)  。

参考资料 https://github.com/MaoliRUNsen/runsenlearnpy100

 

责任编辑:姜华 来源: Python之王
相关推荐

2011-04-20 15:06:44

堆排序

2014-10-30 15:59:10

2009-08-11 09:19:52

C#选择排序C#算法

2011-04-20 16:58:33

java排序

2021-01-21 05:22:36

排序算法选择

2021-01-26 05:33:07

排序算法快速

2021-03-23 08:33:22

Java数据结构算法

2023-10-10 08:00:07

2021-01-20 06:09:30

堆排序TopK应用场景

2011-04-11 14:52:18

选择排序排序C++

2021-11-05 22:47:44

冒泡排序选择插入

2011-04-20 11:22:51

Java

2021-10-31 07:38:37

排序算法代码

2023-10-05 09:01:05

插入排序对象序列log2i

2022-11-21 07:58:10

Java排序冒泡排序

2021-06-09 09:06:52

Go语言算法

2015-10-20 15:09:55

排序算法

2021-08-04 08:56:34

语言Go排序

2011-04-20 14:07:37

冒泡排序

2011-04-20 13:56:08

选择排序
点赞
收藏

51CTO技术栈公众号