堆的基本操作（C 语言版）

最新推荐文章于 2022-12-25 22:37:03 发布
最新推荐文章于 2022-12-25 22:37:03 发布
阅读量618 收藏 2
点赞数
分类专栏： # 机试指南 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wugenqiang/article/details/105827159
版权

堆的基本操作（C 语言版）

复习堆的基本操作的C语言实现，以小顶堆为例。因为大顶堆和小顶堆实现的方式差不多，会小顶堆，大顶堆也就会了吧哈哈！

堆的介绍

堆的定义

堆（Heap）就是用数组实现的二叉树，所以它没有使用父指针或者子指针。堆根据“堆属性”来排序，“堆属性”决定了树中节点的位置。常见的堆有二叉堆、左倾堆、斜堆、二项堆、斐波那契堆等等。

堆的常用方法：

  • 构建优先队列
  • 支持堆排序
  • 快速找出一个集合中的最小值（或者最大值）

堆的属性

堆分为两种：最大堆和最小堆，两者的差别在于节点的排序方式。

最大堆（大顶堆）：① 根的值大于左右子树的值 ② 子树也是最大堆

最小堆（小顶堆）：① 根的值小于左右子树的值 ② 子树也是最小堆

最大堆

这是一个最大堆，，因为每一个父节点的值都比其子节点要大。10 比 7 和 2 都大。7 比 5 和 1都大。

堆属性非常的有用，因为堆常常被当做优先队列使用，因为可以快速的访问到“最重要”的元素。

我们准备将上面的例子中的树这样存储：

[ 10, 7, 2, 5, 1 ]

注意：堆有两个性质

  • 结构性：堆必须是一棵完全二叉树
  • 堆序性：堆的父节点要么都大于子节点，要么小于子节点，前者叫大顶堆，后者叫小顶堆；

由此，堆可以用一个数组来表示，并有如下性质：

  • 对于任意 i 位置的元素，他的左子节点在 2 * i 位置，右子节点在 2 * i + 1位置；
  • 2.他的父节点（假如有）在i/2位置

下面以小顶堆的方式对上图进行处理：

小顶堆的实现方式(一)

堆的结构体

//创建一个小顶堆,size代表的是实际元素的个数
typedef struct MinHeap {
    int size;
    int data[MAX_SIZE];
} heap;

初始化堆

//初始化：数组0位置要空着
void init(heap* h ) {
    h->size = 0;
}

插入元素

//插入元素x 
int insert(heap* h, int x) {
	int flag = 1;
    if (h->size == MAX_SIZE) {
        printf("heap is full!");
        flag = 0;
    }
    int i;
    h->size++;
    for (i = h->size; i >= 1; i /= 2) {
        if(x < h->data[i / 2]) {
            h->data[i] = h->data[i/2];
        } else {
            break;
        }
    }
    h->data[i] = x;
    return flag;
}

删除最小元素

//删除最小元素，在小顶堆即意味着删除根节点
int deleteMin(heap* h) {
    int child;
    int result = h->data[1];
    h->data[1] = h->data[h->size];
    h->size--;
    int i = 1;
    int temp = h->data[1];
    for (i = 1; 2 * i <= h->size; i = child) {
        child = 2 * i;
        if (child != h->size && h->data[child] > h->data[child+1]) {
			//如果左子节点非最后元素且>右子节点,则右子节点最小
            child++;
        }
        if (temp > h->data[child]) {
			//如果temp大于当前元素的最小子节点，则将最小子节点赋值给父节点，否则跳出
            h->data[i] = h->data[child];
        } else {
            break;
        }
    }
    h->data[i] = temp;//将缓冲区值赋给当前游标
    return result;
}

堆排序

//堆排序
void heap_sort(int a[], int n) {
    int i;
    heap* h = (heap*)malloc(sizeof(heap));//给堆指针分配空间
    init(h);//初始化堆
    for (i = 0; i < n; i++) {//将数组的元素依次插入堆
        insert(h, a[i]);
    }
    for (i = 0; i < n; i++) {
        a[i] = deleteMin(h);
    }
}

遍历输出数组

//遍历数组
void traverse_array(int a[], int n) {
    int i;
    for (i = 0; i < n; i++) {
        printf("%d ",a[i]);
    }
    printf("\n");
}

完整代码

#include<stdio.h>
#include<stdlib.h>
#define MAX_SIZE 20

//创建一个小顶堆,size代表的是实际元素的个数
typedef struct MinHeap {
    int size;
    int data[MAX_SIZE];
} heap;

//初始化：数组0位置要空着
void init(heap* h ) {
    h->size = 0;
}

//插入元素x 
int insert(heap* h, int x) {
	int flag = 1;
    if (h->size == MAX_SIZE) {
        printf("heap is full!");
        flag = 0;
    }
    int i;
    h->size++;
    for (i = h->size; i >= 1; i /= 2) {
        if(x < h->data[i / 2]) {
            h->data[i] = h->data[i/2];
        } else {
            break;
        }
    }
    h->data[i] = x;
    return flag;
}

//删除最小元素，在小顶堆即意味着删除根节点
int deleteMin(heap* h) {
    int child;
    int result = h->data[1];
    h->data[1] = h->data[h->size];
    h->size--;
    int i = 1;
    int temp = h->data[1];
    for (i = 1; 2 * i <= h->size; i = child) {
        child = 2 * i;
        if (child != h->size && h->data[child] > h->data[child+1]) {
			//如果左子节点非最后元素且>右子节点,则右子节点最小
            child++;
        }
        if (temp > h->data[child]) {
			//如果temp大于当前元素的最小子节点，则将最小子节点赋值给父节点，否则跳出
            h->data[i] = h->data[child];
        } else {
            break;
        }
    }
    h->data[i] = temp;//将缓冲区值赋给当前游标
    return result;
}

//堆排序
void heap_sort(int a[], int n) {
    int i;
    heap* h = (heap*)malloc(sizeof(heap));//给堆指针分配空间
    init(h);//初始化堆
    for (i = 0; i < n; i++) {//将数组的元素依次插入堆
        insert(h, a[i]);
    }
    for (i = 0; i < n; i++) {
        a[i] = deleteMin(h);
    }
}
//遍历数组
void traverse_array(int a[], int n) {
    int i;
    for (i = 0; i < n; i++) {
        printf("%d ",a[i]);
    }
    printf("\n");
}

//主函数测试 
int main() {
    int a[] = {10,7,2,5,1};
    int n = sizeof(a) / sizeof(int);
    traverse_array(a, n);
    heap_sort(a, n);
    traverse_array(a, n);
}

小顶堆的实现方式(二)

堆的结构体

说明：有的时候不会像上面那样定义结构体，可能会用指针定义结构体，比如这样：

typedef struct MinHeap{
    int *data;//表示堆的数组 大小要在用户输入的元素个数上+1
    int Size;//数组里已有的元素(不包含a[0]) 
    int Capacity; //数组的数量上限
}heap;//定义顶堆

如果这样定义，怎么做呢，其实和上面一样，只是定义的形式有区别而已，所以改动的主要就是创建、插入和删除部分。

创建堆(初始化堆)

当然堆的建立这部分要大改：

//创建堆 
heap* init(int size){
    heap* h = (heap*)malloc(sizeof(heap));
    h->data = (int*)malloc(sizeof(int)*(size+1));//从a[1]开始保存数 所以数组数量要+1
    h->Size = 0;
    h->Capacity = size;
    h->data[0] = MinData;//岗哨
    return h;
}

插入元素

 
//插入元素 
int insert(heap* h, int x){
    //判断是否满了
    if (h->Size == h->Capacity) {
        return 0;
    }
    int i = ++h->Size;
    for (; i >= 1; i/=2) {
		if (h->data[i/2] > x) {
			h->data[i] = h->data[i/2];
		} else {
			break;
		}  
    }
    h->data[i] = x;
    return 1;
}

删除元素

//删除最小元素 
int deleteMin(heap* h){
    int top = h->data[1];
    int last = h->data[h->Size];
    h->Size--;
    int i,child;
    for (i = 1; i * 2 <= h->Size; i = child) {
        child = i*2;
            //注意这里是存在右子节点 并且 右子节点比左子节点小    
        if (child!=h->Size && h->data[child] > h->data[child+1]) {
            child++;
    	}
		//如果比右子节点还小
        if (h->data[child]>last) {
            break;
        }else{//下滤
            h->data[i] = h->data[child];
        }
    
    }
    h->data[i] = last;
    return top;
}

堆排序

//堆排序
void heap_sort(int a[], int n) {
    int i;
    heap* h = init(n);//初始化堆
    for (i = 0; i < n; i++) {//将数组的元素依次插入堆
        insert(h, a[i]);
    }
    for (i = 0; i < n; i++) {
        a[i] = deleteMin(h);
    }
}

遍历输出数组

//遍历数组
void traverse_array(int a[], int n) {
    int i;
    for (i = 0; i < n; i++) {
        printf("%d ",a[i]);
    }
    printf("\n");
}

完整代码

#include<stdio.h>
#include<stdlib.h>
#define MinData -1//哨兵元素的值
typedef struct MinHeap{
    int *data;//表示堆的数组 大小要在用户输入的元素个数上+1
    int Size;//数组里已有的元素(不包含a[0]) 
    int Capacity; //数组的数量上限
}heap;//定义顶堆

//创建堆 
heap* init(int size){
    heap* h = (heap*)malloc(sizeof(heap));
    h->data = (int*)malloc(sizeof(int)*(size+1));//从a[1]开始保存数 所以数组数量要+1
    h->Size = 0;
    h->Capacity = size;
    h->data[0] = MinData;//岗哨
    return h;
}
//插入元素 
int insert(heap* h, int x){
    //判断是否满了
    if (h->Size == h->Capacity) {
        return 0;
    }
    int i = ++h->Size;
    for (; i >= 1; i/=2) {
		if (h->data[i/2] > x) {
			h->data[i] = h->data[i/2];
		} else {
			break;
		}  
    }
    h->data[i] = x;
    return 1;
}
//删除最小元素 
int deleteMin(heap* h){
    int top = h->data[1];
    int last = h->data[h->Size];
    h->Size--;
    int i,child;
    for (i = 1; i * 2 <= h->Size; i = child) {
        child = i*2;
            //注意这里是存在右子节点 并且 右子节点比左子节点小    
        if (child!=h->Size && h->data[child] > h->data[child+1]) {
            child++;
    	}
		//如果比右子节点还小
        if (h->data[child]>last) {
            break;
        }else{//下滤
            h->data[i] = h->data[child];
        }
    
    }
    h->data[i] = last;
    return top;
}

//堆排序
void heap_sort(int a[], int n) {
    int i;
    heap* h = init(n);//初始化堆
    for (i = 0; i < n; i++) {//将数组的元素依次插入堆
        insert(h, a[i]);
    }
    for (i = 0; i < n; i++) {
        a[i] = deleteMin(h);
    }
}
//遍历数组
void traverse_array(int a[], int n) {
    int i;
    for (i = 0; i < n; i++) {
        printf("%d ",a[i]);
    }
    printf("\n");
}

//主函数测试 
int main() {
    int a[] = {10,7,2,5,1};
    int n = sizeof(a) / sizeof(int);
    traverse_array(a, n);
    heap_sort(a, n);
    traverse_array(a, n);
}
WuGenQiang
关注
专栏目录
C语言实现堆的基本操作
weixin_44915226的博客
08-22 1836
文章目录前言基本的操作一、头文件及定义堆二、创建最大堆三、判断堆满/空四、插入操作五、删除操作完整代码 前言 本文用C语言实现了堆的基本操作，包括：创建堆、判断堆满/空、插入、删除。虽然在C++的STL中已经分装好了堆数据结构，但是在不少的场合会用到自己写的堆。   基本的操作 堆分为最大堆和最小堆，本文对最大堆进行了说明，最小堆可模仿写出。   一、头文件及定义堆 代码： #include <stdio.h> #include <stdlib.h> #de
用C实现堆的基本操作
d_CSDNW的博客
03-10 320
C语言实现堆
算法与数据结构-堆的基本操作C语言实现
shuaixio的博客
05-21 4570
数据结构，二叉堆，创建/插入/删除，大顶堆/小顶堆，堆调整算法
C语言_堆的基本操作
A__B__C__的博客
09-22 820
本片博客主要包含一下几个内容： 堆的基本操作 1、创建堆 2、调整堆（向下调整） 3、插入 4、移除堆顶元素 5、返回堆元素个数 6、判断是不是空堆 7、返回堆顶元素 8、向上调整堆 9、交换两个数 10、判断堆是否已满，如果满了，就增容；如果没有满，就返回 11、销毁堆 12、小于比较 13、大于比较 14、头文件代码 15、测试代码   1、创建堆 vo...
堆的基础操作（C语言）
最新发布
YuxiaoCyuyan的博客
12-25 249
堆的基础操作（C语言实现）
13 万字 C 语言从入门到精通保姆级教程2021 年版
热门推荐
李南江
06-07 60万+
13 万字C语言保姆级教程，从入门到精通。
C++语言数据结构 串的基本操作实例代码
08-30
本文将深入探讨串的基本操作，包括构造、输出、求长度、比较以及连接和子串提取等实例代码。 1. **构造字符串**： `CreatHString` 函数用于创建一个堆分配表示的串。它首先初始化串的长度为0，然后使用`malloc`...
c 语言电子版
05-12
1. **基本语法**：C语言的语法结构严谨，包括变量声明、数据类型（如int, float, char等）、运算符（算术、比较、逻辑等）、控制结构（if语句、switch语句、for循环、while循环）。 2. **函数**：C语言的核心特性之...
数据结构——串的基本操作（C语言，完整优美实现）
明宇逸风的博客
08-15 2万+
串 文章目录串前言一、串是什么？二、该如何理解串？三、各类串的形式四、串的实现1.串的实现1.1 引入库以及设置结构体1.2初始化串1.3求子串的功能实现1.4两串比较的功能实现1.5定位功能1.6求串的长度功能1.7串的输出功能1.7主函数实现上述全部功能总结 前言 本文就介绍了数据结构中串的基本操作的编程实现，掌握串的建立、遍历，求子串，定位等基本操作 提示：以下是本篇文章正文内容，下面案例可供参考 一、串是什么？ 在计算机程序设计中，字符串 string 通常是字符序列，要么是文字常量，要么是
C语言实现堆数据结构和基本操作
qq_35622134的博客
06-16 270
总有一种在垃圾堆里刨食的感觉，为了让垃圾堆里多一些有用的东西，我特意写了这个文章。主要是一些堆的实现。本文章的代码是从别的地方抄来的，如果原作者不希望代码放在这里，请联系帖主删除帖子。 运行效果：.........
数组堆操作，包括堆排序、堆插入、堆删除等
07-10
数组进行堆操作，包括堆的排序、堆的插入、堆的删除、堆增加值等
c版数据结构--堆的基本操作
Willing_hope的博客
08-18 132
堆：逻辑上是一种特殊的完全二叉树，存储方式上是一个线性表。其基本操作有：堆的创建、堆的向下调整算法、堆的插入、堆的删除、堆的排序等，代码如下： 1、首先自定义堆的库函数 #ifndef _HEAP_H_ #define _HEAP_H_ typedef int HPDataType; typedef struct Heap { HPDataType* data; int size...
堆排序C语言实现以及堆基本操作python实现
NekoCharms的博客
12-19 263
堆排序 堆排序的基本思想： 对于一组待排序数据，首先按堆的定义建立初始堆（大根堆或小根堆）； 取出堆顶元素（最大或最小），将剩余的元素继续调整成新堆，就得到次大或次小元素； 反复执行 1、2 ，直到全部元素排序成顺序或逆序，堆排序结束 #include<stdio.h> // 交换 void swap(int arr[], int i, int j) { int temp = arr[j]; arr[j] = arr[i]; arr[i] = temp; } // 调整堆结构 void
数据结构（C语言）——6堆：实现和操作
<Hunter>
07-12 225
堆的Ｃ语言实现
堆的定义与操作(C语言)
m0_51955470的博客
11-15 322
代码如下: typedef struct HNode *Heap; /* 堆的类型定义 */ struct HNode { ElementType *Data; /* 存储元素的数组 */ int Size; /* 堆中当前元素个数 */ int Capacity; /* 堆的最大容量 */ }; typedef Heap MaxHeap; /* 最大堆 */ typedef Heap MinHeap; /* 最小堆 */ #define MAXDATA
堆--C语言描述
K 的小想法
11-25 294
一. 定义 堆：一个特殊的完全二叉树   (1.)大根堆：根结点的值大于或等于左右结点数据域的值。 （2.）小根堆：根结点的值小于或等于左右结点数据域的值。 二. 堆的创建 步骤：1.创建一个完全二叉树。            2.调整成大（小）根堆。  代码示例如下：此例的储存结构为数组 #include &lt;stdio.h&gt; #include &lt;s...
【学习笔记】堆（c语言）
Zero__two_的博客
01-10 2634
1.堆的概念 堆（heap）是计算机科学中一类特殊的数据结构的统称。堆通常是一个可以被看做一棵树的数组对象。 我们抛去表面看本质：堆就是一种特殊的数组，但在想象中是二叉树的结构，且该二叉树的mei。 2.堆的分类 2.1大根堆 堆中某个结点的值总是不大于其父结点的值 图： 2.2小根堆 堆中某个结点的值总是不小于其父结点的值 图： 3.堆的性质 堆中某个结点的值总是不大于或不小于其父结点的值； 堆总是一棵完全二叉树。 4.将数组建成堆 前面说过堆就是一种特
C语言中的堆及其实现过程
weixin_43886592的博客
08-22 2627
一、堆的概念及结构 如果有一个关键码的集合K = {k0，k1， k2，…，kn-1}，把它的所有元素按完全二叉树的顺序存储方式存储在一个一维数组中，并满足：Ki <= K2i+1 且 Ki<= K2i+2 (Ki >= K2i+1 且 Ki >= K2i+2) i => 0，1，2…，则称为 小堆(或大堆)。将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最...
【C语言】什么是堆？堆排序和TopK问题又是如何实现的
慕雪华年的博客
04-11 1656
文章目录前言1.堆的概念2.堆的实现2.1向上调整2.2向下调整2.3代码测试3.堆排序3.1为什么要进行堆排序？3.2在原本数组上建堆3.2.1向上调整-插入数据3.2.2 向下调整-删除数据3.2.3比较时间复杂度3.3代码示例4.TopK问题4.1问题说明4.2如何求解？4.3测试代码结语 前言 在上一篇数据结构博客中，我带大家一起学习了树以及二叉树这一个全新的数据结构。 【C语言】什么是树，二叉树又是啥玩意 本篇博客，就让我们一起来看看常被人津津乐道的堆排序以及堆这个数据结构是一个什么样的存在吧
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

WuGenQiang

谢谢你的喜欢

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值