#排序算法#【3】堆排序

  堆是一个完全二叉树,树中每个结点对应于原始数据的一个记录,并且每个结点应满足以下条件:非叶结点的数据大于或等于其左、右孩子结点的数据(若是按从大到小的顺序排序,则要求非叶结点的数据小于或等于其左、右孩子结点的数据)。

由堆的定义可看出,其根结点为最大值,堆排序就是利用这一特点进行的。堆排序过程包括两个阶段:

(1)将无序的数据构成堆(即用无序数据生成满足堆定义的完全二叉树)。

(2)利用堆排序(即用上一步生成的堆输出有序的数据)。

  加入有一组要排序的数据:69,65,90,37,92,6,28,54

  1.首先,根据堆的定义,将这组数据生成堆

    a. 从最后一个非叶节点37开始,比较其子节点,若发现左右节点中有一个比该节点大,则将两个节点进行交换

    b. 按照上面的步骤,一遍下来可以将树中最大的节点92筛选到最上面的根节点

    

  2.利用堆进行排序

    a.
因为上面排序一遍过后,最大的节点在根节点,因此将根节点与最后一个节点交换,使最大的节点排在最后

    b.
由于根节点和最后一个节点交换,破坏了原来的堆结构,所以需要对除了最后一个节点外的其他n-1个节点重新生成堆

    c.
重复上面两个步骤,最后剩下的一个节点即为最小节点,排在整个二叉树的根节点,至此则生成从小到大的有序堆

    具体图示如下:

      

(图中输出,即表示为调整到数组最后)

下面贴上具体代码(C语言版):


 1 #include <stdio.h>
2 #include "CreateData.c"  //生成随机数文件
3
4 #define MAXSIZE 10
5
6 //对指定的节点构成堆
7 //int m 指定的节点
8 //int n 数组的元素个数
9 void HeapAdjust(int a[],int m,int n){
10 int i,j,t;
11
12 while(2*m+1 < n){ //指定的节点有左子树
13 j = 2*m+1; //m的左子树
14
15 if(j+1 < n){
16 //有右子树,且右子树大于左子树
17 if(a[j] < a[j+1]) j++;
18 }
19
20
21 if(a[m] < a[j]){
22 //如果有个子树大于根节点,则交换
23 t = a[m];
24 a[m] = a[j];
25 a[j] = t;
26
27 m = j; //交换过以后,以j为根的节点再重新生成堆
28 }else
29 break;
30
31 }
32 }
33
34 //堆排序算法
35 void HeapSort(int a[],int n){
36 int i,t;
37
38 i = n/2-1;
39
40 for(;i>=0;i--)
41 HeapAdjust(a,i,n);
42
43 for(i = n-1;i>=0;i--){
44 //将树根节点(最大)放到最后一个元素
45 t = a[i];
46 a[i] = a[0];
47 a[0] = t;
48
49 //破坏了根节点,再对根节点重新生成堆
50 HeapAdjust(a,0,i);
51 }
52 }
53
54 int main(){
55 int a[MAXSIZE];
56 int i;
57
58
59 if(!CreateData(a,100,10,MAXSIZE)){
60 printf("生成随机数失败.\n");
61 return 0;
62 }
63
64 printf("排序前:");
65 for(i = 0 ; i < MAXSIZE ;i++)
66 printf("%d ",a[i]);
67
68 HeapSort(a,MAXSIZE);
69
70 printf("\n排序后:");
71 for(i = 0 ; i < MAXSIZE ;i++)
72 printf("%d ",a[i]);
73 printf("\n");
74
75 return 1;
76 }

  此段代码在调试的过程中比较坎坷,在Linux中有时候会发现比较古怪的问题,比如陷入死循环但是很难追踪,不过都是个人粗心,有几个变量赋值和循环条件刚开始的时候写错了。不过现在经测试已经运行稳定,并实现从小到大进行数据排序功能。

#排序算法#【3】堆排序,布布扣,bubuko.com

时间: 2024-10-17 16:15:48

#排序算法#【3】堆排序的相关文章

排序算法系列——堆排序

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

排序算法之堆排序(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)都是堆. 如果将堆对应的一维数组看成是一个二叉树,则堆的含义表明:完全二叉树中所有非终端结

排序算法(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. 堆: 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++) {