排序算法(2) 堆排序 C++实现

堆


1 数组对象

2 可以视为一棵完全二叉树

3 一个堆可以被看作一棵二叉树和一个数组，如下图所示：


4 下标计算（通常使用内联函数或者宏来定义下标操作）：

  • 已知某个结点的下标为i

  • 其父节点下标：i/2向下取整

  • 左孩子下标：2i

  • 右孩子下标：2i+1

5 最大堆：除根节点以外的每个节点i，有A[PARENT(i)] >= A[i]

最小堆：除根节点意外的每个节点i，有A[PARENT(i)] <= A[i]

堆排序


步骤：

  1. 建大顶堆
  2. 去堆顶元素与当前堆的最后一个元素进行互换。
  3. 该堆顶元素已达最终位置，排除出堆
  4. 对剩下的堆进行最大堆调整
  5. 重复2到4步

排序过程


1 建堆过程


1）
从第一个非叶子节点开始，对value为8的节点进行调整，无需调整。

2） 对value值为9的节点进行调整。


3） 对value为2的节点调整


4） 对value为3的节点进行调整

     ----》

5） 对value为7的节点进行调整

  ---》

建堆完成


2 堆顶元素与当前堆的最后一个元素进行互换。

3 该堆顶元素已达最终位置，排除出堆


4 对剩下的堆进行调整


递归进行堆首和堆尾互换以及调整堆的步骤，结果即为排好序的堆。


代码实现

?





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

29

30

31

32

33

34

35

// heapsort.h

class
HeapSort:public
BaseSort {

public:

    HeapSort(int
Array[], int
len) : BaseSort() {

        this-&gt;Array = Array;

        this-&gt;len = len;

    }

    void
sort();

private:

    /* 建堆 */

    void
buildMaxHeap();

    /* 调整堆，以保持最大堆性质 */

    void
maxHeapIfy( int
i , int
curlen);

    /* 堆排序 */

    void
heapSort();

    /* 返回父节点下标 */

    int
Parent(int
i) {

        if
( i % 2 == 0 )

            return
i/2;

        else

            return
i/2 + 1;

    };

    /* 返回左孩子节点下标 */

    int
Left(int
i) { return
2 * i + 1; };

    /* 返回右孩子节点下标 */

    int
Right(int
i) { return
2 * i + 2; };

private:

    int* Array;

    int
len;

};

相关成员函数实现

?





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

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

// heapsort.cpp

#include "heapsort.h"

void
HeapSort::sort() {

    heapSort();

}

void
HeapSort::heapSort() {

   

    buildMaxHeap();

    int
i = this->len;

    int
tmp;

    while( i > 0 ) {

        tmp = this->Array[0];

        this->Array[0] = this->Array[i-1];

        this->Array[i-1] = tmp;

        i--;

        maxHeapIfy(0, i);

    }

}

void
HeapSort::maxHeapIfy( int
i, int
curlen ) {

    int
left, right, largest;

    int
tmp;

    left = Left(i);

    right = Right(i);

    if
( left < curlen-1

        && Array[left] > Array[i])

        largest = left;

    else

        largest = i;

    if
( right < curlen-1

        && Array[right] > Array[largest])

        largest = right;

    if
( largest != i ) {

        tmp = Array[i];

        Array[i] = Array[largest];

        Array[largest] = tmp;

        maxHeapIfy(largest, curlen);

    }

}

void
HeapSort::buildMaxHeap() {

    int
i;

    for
( i = (len-1)/2 ; i >= 0; i-- ) {

        maxHeapIfy(i, len);

        if
(DEBUG) {

            printArray(this->Array, this->len, "midResult");

        }

    }

}

测试代码：

?





1

2

3

4

5

/* --------- HeapSort -------- */

int b[10] = {7,3,2,9,8,5,1,10,4,6};

HeapSort* heapsort = new
HeapSort(b, len);

heapsort->sort();

printArray(b, len, "HeapSort ");

参考资料：

《算法导论 2rd》

http://www.cnblogs.com/Anker/archive/2013/01/23/2873422.html 
《算法导论》读书笔记之第6章 堆排序

时间： 2024-10-27 12:59:55

排序算法(2) 堆排序 C++实现的相关文章

排序算法系列——堆排序

记录学习点滴,菜鸟成长记 堆排序引入了另一种算法设计技巧:使用一种我们称之为“堆”的数据结构来进行数据管理. 堆排序算是真正意义上的利用数据结构来求解数组排序的方法. “插入排序”和“归并排序”可以看做是一种“计算机体力活”,体现的思想更多的是去模拟最简单的人类思维,比如插入排序过程中的比较,归并中子问题合并时的比较. “堆排序”可以看做是“计算机脑力活”,他利用了一种结构化的语言来表达,这种结构化带来一些性质,比如左右孩子.比[堆大小的一半向下取整]大的下标都是叶节点不需要维护其最大堆性质等.

排序算法之堆排序（Heapsort）解析

一.堆排序的优缺点(pros and cons) (还是简单的说说这个,毕竟没有必要浪费时间去理解一个糟糕的的算法) 优点: 堆排序的效率与快排.归并相同,都达到了基于比较的排序算法效率的峰值(时间复杂度为O(nlogn)) 除了高效之外,最大的亮点就是只需要O(1)的辅助空间了,既最高效率又最节省空间,只此一家了 堆排序效率相对稳定,不像快排在最坏情况下时间复杂度会变成O(n^2)),所以无论待排序序列是否有序,堆排序的效率都是O(nlogn)不变(注意这里的稳定特指平均时间复杂度=最坏时间复

排序算法： 堆排序法

一,使用堆排序法之前,需要了解堆的特性: 1,堆一般都用数组的方式来存储,堆分为“最大堆”和“最小堆”: 2,以“最大堆”为例: (1)一个节点最多有两个子节点,即左右节点,每个节点都是一个堆: (2)父节点的值不小于子节点的值: (3)一个i节点,其父节点为(i-1)/2,左节点(2*i+1),右节点(2*i+2) 一个最大堆例子: 数组 int a[]: 83 78 81 48 17 27 二,将一个数组形成堆(以最大堆为例) 数组a[]: 27 48 81 78 17 83 形成最大堆思路

排序算法之堆排序（优先队列）

1.堆排序的堆,其实是一个 完全二叉树.既是一个结点要么是叶子结点,要么必定有左右两个子节点的树. 2.堆有序:每个结点的值,都必须大于两个子节点.但是两个子结点的大小不作要求. 3.一棵大小为N的完全二叉树,高度为lgN(层). 用数组实现堆,假设数组下标从0开始,下标为k的元素,它的左子树是2k+1,右子树是左子树+1,即2k+2 一:由上至下的有序化(下沉) 如果堆的有序状态,因为某个结点比它的两个子结点或者其中之一小而打破了,那么可以通过与两个子结点中的较大者来交换. 交换后可能会在子结

排序算法之堆排序

1. 堆排序的思想 输入一个数组,利用一组二叉树的操作使其变成有序的数组,就是堆排序 堆排序利用的是二叉树的思想,操作对象是数组,所以数组需要在逻辑上映射到二叉树上,由于数组的下标是连续的,而二叉树中只有完全二叉树和满二叉树是连续的,所以将数组元素逐个映射到完全二叉树上,然后配备一系列的操作即可.例如数组data[]={9,6,5,4,3,2,1,7},映射到完全二叉树上如下图所示. 2.堆排序的过程 还是用上面的data数组作为输入数组,映射到完全二叉树如上图所示,怎么利用二叉树的性质,才能使

算法学习之排序算法：堆排序

要了解堆排序,首先要了解堆的概念,因为本文主要研究堆排序的算法,此处对数据结构堆只是给出概念:n个元素的序列{k1,k2,...kn},当且仅当满足如下关系时,称之为堆. k[i] <= k[2i]且k[i] <= k[2i+1] (或 k[i] >= k[2i]且k[i] >= k[2i+1]) 比如:序列96.83.27.38.11.09(或12.36.24.85.47.30.53.91)都是堆. 如果将堆对应的一维数组看成是一个二叉树,则堆的含义表明:完全二叉树中所有非终端结

排序算法：堆排序

堆排序 1. 堆: 1. 一种完全二叉树. 2. 每个结点的值都大于或等于其左右子结点的值,大顶堆. 3. 小顶堆同理. 2. 是简单选择排序的一种改进:把每次比较的结果用堆来保存起来. 3. 堆排序(大顶堆): 1. 将待排序列构造成一个大顶堆. 2. 将堆顶和待排序列最后一个元素交换,也就是保存起来. 3. 将剩余的序列(去除最后一个元素)重新构造成一个堆. 4. 重复23 . 4. 待排序列构造初始大顶堆: 1. 设序列长度length,已经构造好最初的完全二叉树,无序. 2. 从最下层最

初级排序算法之堆排序

堆排序的思想 堆排序的具体算法,思想是每次取出堆的最顶层根节点,即数组下标为0,然后与最后一个节点即i+1交换. 参考地址 建堆过程: 首先将原始队列构建成完全二叉树 然后从第一个非叶子节点开始,比较当前节点和其孩子节点,将最大的元素放在当前节点,交换当前节点和最大节点元素. 注意:如果根节点是a[0],那么第一个非叶子节点就是倒数第二层的最后一个根节点,下标为length/2-1 将当前元素前面所有的元素都进行2的过程,这样就生成了最大堆 /** * @param data 原始数组序列 *

排序算法（堆排序）

堆排序是对选择排序的改进(时间复杂度和希尔排序一样O(nlog2n)) 数据结构:完全二叉树(大顶堆,根节点都比左右节点大,小顶堆,根节点小于双亲节点) public class HeapSort {    public static void main(String[] args) {        int a[]={1,2,4,9,33,2,6,7,10,11};        sort(a, 10);        for (int i = 0; i < a.length; i++) {