算法导论之堆排序

最新推荐文章于 2025-06-15 17:58:09 发布
最新推荐文章于 2025-06-15 17:58:09 发布
阅读量630 收藏
点赞数 1
CC 4.0 BY-SA版权
分类专栏： 算法导论 C语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/ooooo12345re/article/details/50673602

    （二叉）堆，是一个数组，可以被看成一个近似的完全二叉树，树上的每一个节点对应于数组中的一个元素。除了最底层之外，该树是完全充满的，而且是从左向右填充，A.length表示数组元素的个数，树的根结点是A[1],

这样给定一个节点的下标i，我们很容易计算出其父节点（i / 2），左子女（2 * i），右子女（2 * i + 1）；二叉堆又分为两种形式：最大堆（也称为大根堆）和最小堆（也称为小根堆）。在最大堆中，最大堆性质是指除了根以外的所有节点i都满足： A[PARENT(i)] >= A[i]   (即就是根结点的值比左右子女的值都大)；最小堆则恰恰相反，最小堆性质是指除了根以外的所有节点i都有：A[PARENT(i)]  <= A[i], (即就是最小的元素存放在根结点)。

       在堆排序算法中，我们使用的是最大堆，最小堆通常用于构造优先队列。

如图则分别表示了最大堆和最小堆。

        本文章为大家介绍堆排序的两种实现方式：第一种则是真真切切的创建一个堆，其步骤大概有以下几步：

1.首先借助队列按层创建出一个完全二叉树，2.对数据域的值用非递归方式调整成一个大根堆，3.在进行堆排序； 第二种则是比较简单的一种方式，所有的操作都在数组上进行，利用下标可以将数组逻辑看成一个完全二叉树，然后用递归方式调整成一个堆，最后进行排序。总的来说，第二种方式比较好（算法导论上也是这么介绍的）。

         先来看第一种的实现：

heapsort.h 和heapsort.c 的具体实现如下：

#ifndef _HEAP_H
#define _HEAP_H


#define N 10
typedef struct node{
    int data;
    struct node *left;
    struct node *right;
}Heapnode;

//创建完全二叉树
Heapnode *Creat_tree(int data[],int n,Heapnode ** Q);
//堆排序
void Heapsort(Heapnode *root,Heapnode **Q,int n);
//打印
void Print(Heapnode ** Q,int n);



#endif

#include <stdio.h>
#include <stdlib.h>
#include "tools.h"
#include "heapsort.h"



//创建完全二叉树
Heapnode *Creat_tree(int data[],int n,Heapnode ** Q)
{
    Heapnode *root = NULL,*newp = NULL,*cp = NULL;
    int front = 0;
    int real = 0;
    int pa = 1;
    int i = 0;
    //创建根结点
    for(i = 0;i < n;++i){
        newp = (Heapnode *)Malloc(sizeof(Heapnode));
        newp ->data = data[i];
        newp ->right = NULL;
        newp ->left = NULL;
        if(!root){
            root = newp;
        }else{
            cp = Q[pa];
            if(!cp->left){
                cp ->left = newp;
            }else{
                cp ->right = newp;
                pa++;
            }
        }
        //入队
        Q[++real] = newp;
    }
    return root;
}

//堆排序
void Heapsort(Heapnode *root,Heapnode **Q,int n)
{
    int r = 0,pa = 0;
    int tag = 0,t = 0;
    r = n;
    while(r > 1){
        while(1){
        //调整成堆
            pa = r / 2;
            tag = 0;
            while(pa > 0){
                if(Q[pa] ->data < Q[pa] ->left ->data){
                    t = Q[pa] ->data;
                    Q[pa] ->data = Q[pa] ->left ->data;
                    Q[pa] ->left ->data = t;
                    tag = 1;
                }
                if(Q[pa] ->right && Q[pa] ->data < Q[pa] ->right ->data){
                    t = Q[pa] ->data;
                    Q[pa] ->data = Q[pa] ->right ->data;
                    Q[pa] ->right ->data = t;
                    tag = 1;
                
                }
                pa--;
            }
            if(tag == 0){
                break;
            }
        }
        //交换
        t = Q[1] ->data;
        Q[1] ->data = Q[r] ->data;
        Q[r] ->data = t;
   
        if(Q[r / 2] ->right){
            Q[r / 2] ->right = NULL;
        }else{
            Q[r / 2] ->left = NULL;
        }
        r--;
    }
}

//打印
void Print(Heapnode ** Q,int n)
{
    int i = 0;
    for(i = n;i > 0;--i){
        printf("%5d",Q[i] ->data);
    }

}

主函数： 

#include <stdio.h>
#include <stdlib.h>
#include "heapsort.h"
#include "tools.h"

int main(int argc,char** agrv)
 {
     Heapnode **Q = NULL;
     Heapnode *root = NULL;
     int a[] = {3,2,5,8,4,7,9,0,6,1};
     int n = sizeof(a) / sizeof(a[0]);
     Q = (Heapnode **)Malloc(sizeof(Heapnode *) * (n + 1));
     root = Creat_tree(a,n,Q);
     printf("排序前:\n");
     Print(Q,n);
     printf("\n");
     Heapsort(root, Q ,n);
     printf("排序后:\n");
     Print(Q,n);
     printf("\n");
     return 0;
 }

tools.h 和tools.c 的实现如下：

#ifndef _TOOLS_H_
#define _TOOLS_H_

#include <stdio.h>
#include <stdlib.h>
//定义布尔类型
#define TRUE   (1)
#define FALSE  (0)


typedef unsigned char Boolean;

//定义接口
void *Malloc(size_t size);
void *Realloc(void * ptr,size_t size);
void print_int(void *value);
#endif

#include <stdio.h>
#include <stdlib.h>
#include "tools.h"

void *Malloc(size_t size)
{
    void *result = malloc(size);
    if(result == NULL){
        fprintf(stderr,"the memory is full!\n");
        exit(1);
    }
    return result;
}

void *Realloc(void * ptr,size_t size)
{
    void *result = realloc(ptr,size);
    if(result == NULL){
        fprintf(stderr,"the memory is full!\n");
        exit(1);
    }
    return result;
}
void print_int(void *value)
{
    int *p = (int *)value;
    printf("%5d",*p);
}


其中Q为一个动态申请的队列，Creat_tree为创建完全二叉树的过程，（借助于队列），Heapsort为堆排序的过程，首先将创建好的二叉树调整成一个完全二叉树，其调整过程为一个非递归。

接下来，我们看程序的执行结果：

虽然实现了排序过程，但是我们是完全没有必要创建出二叉树，我们完全可以当成是逻辑上的二叉树。


接下来我们看第二种实现方式：

heapsort.h 和heapsort.c的具体实现如下：

#ifndef _HEAP_H
#define _HEAP_H


#define N 10

//调整为大根堆的过程
void  Max_heapify(int *data,int i, int n);
//从无序的输入数据数组中构造一个最大堆
void Build_max_heap(int *data,int n);
//堆一个数组进行原址排序
void Heap_sort(int *data,int n);
//打印数组
void print_array(int *data,int n);

#endif

#include <stdio.h>
#include <stdlib.h>
#include "tools.h"
#include "heapsort.h"

static void swap(int *a,int *b)
{
    int temp;
    temp = *a;
    *a = *b;
    *b = temp;
}
static int Left(int i)
{
    return 2 * i;
}

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

static int  Parent(int i)
{
    return i / 2;
}
//调整为大根堆
void  Max_heapify(int *data,int i,int n)
{
    int left = Left(i);
    int right = Right(i);
    int largest = 0;
    int length = n;

    if(left <= length && data[left - 1] > data[i - 1]){
        largest = left;
    }else{
        largest = i;
    }
    
    if(right <= length && data[right - 1] > data[largest - 1]){
        largest = right;
    }
    if(largest != i){
        swap(&data[i - 1],&data[largest - 1]);
        Max_heapify(data,largest,n);
    }

}

void Build_max_heap(int *data,int n)
{
    int i = 0;
    for(i = n / 2;i >= 1;i--){
        Max_heapify(data,i,n);
    }
}

void Heap_sort(int *data,int n)
{
    int length = n;
    int  i = 0;
    Build_max_heap(data,n);
    for(i = length;i >= 1;--i){
        swap(&data[i - 1], &data[0]);
        n--;
        Max_heapify(data,1,n);
    }
}
void print_array(int *data,int n)
{
     int i = 0;
     for( i = 0; i < n; ++i){
         printf("%5d",data[i]);
     }
     printf("\n");
}

其中Build_max_heap函数为逻辑上的大根堆，该函数调用了Max_heapify函数，该函数主要是进行调整使得根结点的值大于左右子女的值，Heap_sort为堆排序过程，遍历数组，将逻辑上的大根堆根节点的值和最后一个叶子的值进行交换，则最大值已经位于数组的尾部，然后长度减1，继续调用Max_heapify调整成大根堆，继续循环。

接下来我们看主程序：

#include <stdio.h>
#include <stdlib.h>
#include "heapsort.h"
#include "tools.h"


int main(int argc,char **argv)
{
    int data[N];
    int i = 0;

    srand(time(0));
    for(i = 0;i < N; ++i){
        data[i] = rand() % 100;
    }
   

    printf("排序前:\n");
    print_array(data,N);

    Heap_sort(data,N);

    printf("排序后:\n");
    print_array(data,N);
    return 0;
}

执行结果如下图：


两种方式的堆排序已经实现，我还是比较喜欢第二种，逻辑上的数据结构，正是因为数组可以利用下标直接访问，使得堆排序变得简单。堆的应用远不止如此，下一节将会介绍优先队列，也是堆的应用，尽管堆排序是比较好的算法，但在实际应用中，快速排序的性能一般会优于堆排序，快速排序也会在以后的博客进行实现，大家敬请期待！！！

【算法导论】堆排序
grefwfdxz
08-10 450
什么是排序? 考虑对于给定输入的某一个数组 A={a1,a2,...,an}A = \{a_1, a_2,..., a_n\}A={a1​,a2​,...,an​}, 经过排序算法，我们可以得到原始排列的一个序列A={a1′,a2′,...,an′}A=\{a_1^{&#x27;}, a_2^{&#x27;},..., a_n^{&#x27;}\}A={a1′​,a2′​,...
《算法导论》的堆排序
王飞平的博客
07-28 460
#include #include void BUILD_MAX_HEAP(int A[],int length) { int heapsize; int i; heapsize = length; for(i = (int)(heapsize/2);i>=0;i--) MAX_HEAPIFY(A,i,heapsize); } void MAX_HEAPIFY(int A[],in
[算法导论]堆排序
A beginner's learning path
03-17 258
  #include&lt;stdio.h&gt; #include&lt;iostream&gt; using namespace std; #define Length 10 void MaxHeapify(int num[], int i, int len); void BuildHeap(int num[], int len); int Heapsort(int num[],...
算法导论第六章：堆排序与优先队列的艺术
最新发布
SEU123WW的博客
06-15 888
本文是《算法导论》精讲专栏第六章，通过堆结构可视化、动态操作演示和性能对比实验，结合完整C语言实现，深入解析堆排序与优先队列的精髓。包含堆的基本操作、堆排序算法、优先队列实现以及堆在图算法中的应用，提供10个以上C语言代码实现。
算法导论中堆排序c++源程序
04-23
算法导论上的堆排序c++源程序||学习分享
算法导论 快速排序 堆排序 代码 可运行
10-26
算法导论 快速排序 堆排序 算法导论上的算法实现更加精简高效 代码可编译运行测试 加了测试用例 加了注释
堆排序代码 《算法导论》
06-05
参考《算法导论》这本书写的一个堆排序的代码，我个人是用Visual studio写的。只要一个积分哦
堆排序（C#，C++）算法导论
10-11
堆排序是一种基于比较的排序算法，它通过构造一个近似完全二叉树的堆数据结构来实现排序。...在“算法导论第三版第六章”中，作者深入探讨了这些概念和实现细节，帮助读者理解堆排序的原理及其在不同编程语言中的实现。
《算法导论》第六章 -- 堆，堆排序(含习题)
weixin_40085040的博客
03-08 1207
堆   堆，一般是指二叉堆，是指如下的数据结构   将一个数组上的元素从头到尾按照从左向右、从上向下的方式填到一颗二叉树上，就是一个堆。一个最大/小堆表示满足父节点总是大于/小于子节点的堆。 堆用于排序的思想   因为堆上的很多操作只需要lgnlgnlgn的时间（包括从一个最大/小堆上取出最大/小值），所以堆可以用于在O(nlgn)O(nlgn)O(nlgn)时间内进行排序。   但是我认为堆最大的用处不在于排序， 而是在于堆维护自己的堆性质的操作基本上只需要lgnlgnlgn的执行时间，当需要对某个数据
算法导论------堆排序
weixin_38853761的博客
09-13 206
一 堆定义 堆(Heap)是计算机科学中一类特殊的数据结构的统称。堆通常是一个可以被看做一棵完全二叉树的数组对象。如下所示： 二 堆的性质 假设堆是使用数组进行存储的，那么对于堆中的节点 i ，其对应的相关性质如下： PARENT(i) = i / 2 // 父节点计算 LEFT(i) = i * 2 // 左孩子节点计算 RIGHT(i) = i * 2 + 1 // 右孩子节点计算 三 最大堆和最小堆 3.1 最大堆性质 最大堆的简单概括就是堆中任意一个节点的父节点，都比该任意节点的值要大。即： PA
算法导论--堆排序
Mr_Fogg的专栏
06-03 617
堆排序涉及到一个数据结构就是“堆”，所以我们先从“堆”开始讲起。一、堆堆的存储方式其实就是一个数组，而堆的逻辑结构是一个完全二叉树（什么是完全二叉树请自行百度）。如图（a）是一个完全二叉树，树的父节点都比孩子节点要大，这个就是“大根堆”,如果树的父节点都比孩子节点小，那么就是一个“小根堆”。而图（b）则表示了一个图（a）是如何存储的。这样就很容易计算每个节点的父节点，左孩子节点，右孩子节点。 例如
算法导论：堆排序
吴雒的博客
06-24 296
堆排序代码（python 2）只是实现了堆排序的核心代码：堆维护性质（max_heapify）,而后的建堆、及排序都是基于堆得维护性质算法进行调用即可，暂时不做详解。注意： 为了和书中的伪代码一致，对堆（以数组的形式表示）的操作从数组的第二个元素array[1]开始，第一个元素不作处理初始为0。堆维护性质算法1、基于递归实现：""" warning: 1, This codes are b
算法导论 - 堆排序
u012912039的专栏
10-08 668
注意：为了更好的学习理解，本文实现了MATLAB程序，本文图示大部分是书籍的截图，因为书籍中的图示和解释非常严谨、非常详细、非常棒！ 堆排序 目录 一、引言 二、维护堆的性质 三、建堆 四、堆排序算法 五、优先队列 六、参考文献 一、引言 1. 什么是堆？ 如上图所示，（二...
算法导论——堆排序
The_Only_God的博客
07-20 222
文章目录堆堆排序算法c/c++源码 堆 堆：近似二叉树 例： 最大堆：任意一个结点的值不超过其父结点。 最小堆：任意一个结点的值不小于其父结点。 结点的高度：该结点到叶结点最长简单路的边数。 堆排序算法 构建最大堆取出根维护最大堆 c/c++源码 #include<iostream> using namespace std; int heap_size; void exchang...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值