追梦之旅【数据结构篇】——详解小白如何使用C语言实现堆数据结构

简介: 堆的概念及结构如果有一个关键码的集合K = { , , ,…, },把它的所有元素按完全二叉树的顺序存储方式存储在一个一维数组中,并满足:父结点的值都大于孩子结点的值,则称为大堆;父结点的值都小于孩子结点的值,则称为小堆;大堆也称为大根堆,小堆也叫做小根堆。

微信图片_20230427214238.gif

😎博客昵称:博客小梦

😊最喜欢的座右铭:全神贯注的上吧!!!

😊作者简介:一名热爱C/C++,算法等技术、喜爱运动、热爱K歌、敢于追梦的小博主!

😘博主小留言:哈喽!😄各位CSDN的uu们,我是你的博客好友小梦,希望我的文章可以给您带来一定的帮助,话不多说,文章推上!欢迎大家在评论区唠嗑指正,觉得好的话别忘了一键三连哦!😘


微信图片_20230427160707.gif


前言🙌



   哈喽各位友友们😊,我今天又学到了很多有趣的知识,现在迫不及待的想和大家分享一下!😘我仅已此文,手把手带领大家追梦之旅【数据结构篇】——详解小白如何使用C语言实现堆数据结构~ 都是精华内容,可不要错过哟!!!😍😍😍


什么是堆?


堆的概念及结构


如果有一个关键码的集合K = { , , ,…, },把它的所有元素按完全二叉树的顺序存储方式存储在一个一维数组中,并满足:


父结点的值都大于孩子结点的值,则称为大堆;

父结点的值都小于孩子结点的值,则称为小堆;

大堆也称为大根堆,小堆也叫做小根堆。


堆的性质:


堆中某个节点的值总是不大于或不小于其父节点的值;

堆总是一棵完全二叉树。

微信图片_20230428203915.png微信图片_20230428203920.png


堆的实现


堆向下调整算法


现在我们给出一个数组,逻辑上看做一颗完全二叉树。我们通过从根节点开始的向下调整算法可以把它调整成一个小堆。向下调整算法有一个前提:左右子树必须是一个堆,才能调整


画图分析:


微信图片_20230428203947.png微信图片_20230428203952.png


堆向下调整算法源代码分享:


向下调整建小堆


//向下调整--建小堆
void AdjustDown(int* a, int size, int parent)
{
  int child = parent * 2 + 1;
  while (child < size)
  {
    if (child + 1 < size && a[child + 1] < a[child])
    {
      child++;
    }
    if (a[child] < a[parent])
    {
      Swap(&(a[parent]), &(a[child]));
      parent = child;
      child = parent * 2 + 1;
    }
    else
    {
      break;
    }
  }
}


向下调整建大堆


//建大堆
void AdjustDown(int* a, int size, int parent)
{
  int child = parent * 2 + 1;
  while (child < size)
  {
    if (child + 1 < size && a[child + 1] > a[child])
    {
      child++;
    }
    if (a[child] > a[parent])
    {
      Swap(&(a[parent]), &(a[child]));
      parent = child;
      child = parent * 2 + 1;
    }
    else
    {
      break;
    }
  }
}


堆向上调整算法源代码分享:


画图分析:


微信图片_20230428204103.png微信图片_20230428204107.png


向上调整建小堆


void AdjustUp(HPDataType* a, int child)
{
  assert(a);
  while (child > 0)
  {
    int parent = (child - 1) / 2;
    if (a[child] < a[parent])
    {
      Swap(&(a[child]), &(a[parent]));
      child = parent;
      parent = (child - 1) / 2;
    }
    else
    {
      break;
    }
  }
}


向上调整建大堆


//向上调整建大堆
void AdjustUp(HPDataType* a, int child)
{
  assert(a);
  while (child > 0)
  {
    int parent = (child - 1) / 2;
    if (a[child] > a[parent])
    {
      Swap(&(a[child]), &(a[parent]));
      child = parent;
      parent = (child - 1) / 2;
    }
    else
    {
      break;
    }
  }
}


C语言整体实现堆数据结构源代码分享


堆的插入:


先插入一个10到数组的尾上,再进行向上调整算法,直到满足堆。


微信图片_20230428204215.png

void HeapPush(HP* php, HPDataType x)
{
  assert(php);
  //扩容
  if (php->capacity == php->size)
  {
    int newcapacity = php->capacity == 0 ? 4 : php->capacity * 2;
    HPDataType* tem = (HPDataType*)realloc(php->a, sizeof(HPDataType) * newcapacity);
    if (tem == NULL)
    {
      printf("realloc fail\n");
      exit(-1);
    }
    php->a = tem;
    php->capacity = newcapacity;
  }
  php->a[php->size] = x;
  //向上调整--建小堆
  if(php->size > 0)
    AdjustUp(php->a, php->size);
  php->size++;  
}


堆的删除:


删除堆是删除堆顶的数据,将堆顶的数据和最后一个数据一换,然后删除数组最后一个数据,再进行向下调整算法。


画图分析:



微信图片_20230428204251.png


void HeapPop(HP* php)
{
  assert(php);
  assert(!HeapEmpty(php));
  Swap(&(php->a[0]), &(php->a[php->size - 1]));
  php->size--;
  AdjustDwon(php->a, php->size,0);
}


头文件(Heap.h)编写:


#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>
typedef int HPDataType;
typedef struct Heap
{
  HPDataType* a;
  int size;
  int capacity;
}HP;
void Swap(HPDataType* p1, HPDataType* p2);
// O(logN)
void AdjustDwon(HPDataType* a, int size, int parent);
void AdjustUp(HPDataType* a, int child);
void HeapPrint(HP* php);
void HeapInit(HP* php);
void HeapDestroy(HP* php);
void HeapPush(HP* php, HPDataType x);
void HeapPop(HP* php);
HPDataType HeapTop(HP* php);
bool HeapEmpty(HP* php);
int HeapSize(HP* php);


功能文件(Heap.c)编写:


#define _CRT_SECURE_NO_WARNINGS 1
#include"Heap.h"
void Swap(HPDataType* p1, HPDataType* p2)
{
  int tem = *p1;
  *p1 = *p2;
  *p2 = tem;
}
// O(logN)
//建小堆
void AdjustDwon(HPDataType* a, int size, int parent)
{
  assert(a);
  int child = parent * 2 + 1;
  while (child < size)
  {
    //选出最小的那个
    if (child + 1 < size && a[child + 1] < a[child])
    {
      child++;
    }
    if (a[child] < a[parent] )
    {
      Swap(&(a[parent]), &(a[child]));
      parent = child;
      child = parent * 2 + 1;
    }
    else
    {
      break;
    }
  }
}
void AdjustUp(HPDataType* a, int child)
{
  assert(a);
  while (child > 0)
  {
    int parent = (child - 1) / 2;
    if (a[child] < a[parent])
    {
      Swap(&(a[child]), &(a[parent]));
      child = parent;
      parent = (child - 1) / 2;
    }
    else
    {
      break;
    }
  }
}
void HeapPrint(HP* php)
{
  assert(php);
  for (int i = 0; i < php->size; i++)
  {
    printf("%d ", php->a[i]);
  }
  printf("\n");
}
void HeapInit(HP* php)
{
  assert(php);
  php->a = NULL;
  php->capacity = php->size = 0;
}
void HeapDestroy(HP* php)
{
  assert(php);
  free(php->a);
  php->a = NULL;
  php->capacity = php->size = 0;
}
void HeapPush(HP* php, HPDataType x)
{
  assert(php);
  //扩容
  if (php->capacity == php->size)
  {
    int newcapacity = php->capacity == 0 ? 4 : php->capacity * 2;
    HPDataType* tem = (HPDataType*)realloc(php->a, sizeof(HPDataType) * newcapacity);
    if (tem == NULL)
    {
      printf("realloc fail\n");
      exit(-1);
    }
    php->a = tem;
    php->capacity = newcapacity;
  }
  php->a[php->size] = x;
  //向上调整--建小堆
  if(php->size > 0)
    AdjustUp(php->a, php->size);
  php->size++;
}
void HeapPop(HP* php)
{
  assert(php);
  assert(!HeapEmpty(php));
  Swap(&(php->a[0]), &(php->a[php->size - 1]));
  php->size--;
  AdjustDwon(php->a, php->size,0);
}
HPDataType HeapTop(HP* php)
{
  assert(php);
  assert(!HeapEmpty(php));
  return php->a[0];
}
bool HeapEmpty(HP* php)
{
  assert(php);
  return php->size == 0;
}
int HeapSize(HP* php)
{
  assert(php);
  return php->size;
}


测试文件(test.c)编写:


#define _CRT_SECURE_NO_WARNINGS 1
#include"Heap.h"
void HeapTest1()
{
  HP h;
  HeapInit(&h);
  HeapPush(&h, 15);
  HeapPush(&h, 18);
  HeapPush(&h, 19);
  HeapPush(&h, 25);
  HeapPush(&h, 28);
  HeapPush(&h, 34);
  HeapPush(&h, 65);
  HeapPush(&h, 49);
  HeapPush(&h, 27);
  HeapPush(&h, 37);
  HeapPush(&h, 10);
  printf("%d\n", HeapSize(&h));
  HeapPrint(&h);
  for (int i = 0; i < 8; i++)
  {
    printf("%d ", HeapTop(&h));
    HeapPop(&h);
  }
  printf("\n");
  HeapDestroy(&h);
  printf("%d ", HeapTop(&h));
  HeapPop(&h);
}
int main()
{
  HeapTest1();
  return 0;
}


运行结果测试截图:


微信图片_20230428204425.png


总结撒花💞


   本篇文章旨在分享详解小白如何使用C语言实现堆数据结构。希望大家通过阅读此文有所收获

   😘如果我写的有什么不好之处,请在文章下方给出你宝贵的意见😊。如果觉得我写的好的话请点个赞赞和关注哦~😘😘😘

相关文章
|
3天前
|
定位技术 C语言
c语言及数据结构实现简单贪吃蛇小游戏
c语言及数据结构实现简单贪吃蛇小游戏
|
22天前
|
搜索推荐 C语言
数据结构(C语言)之对归并排序的介绍与理解
归并排序是一种基于分治策略的排序算法,通过递归将数组不断分割为子数组,直到每个子数组仅剩一个元素,再逐步合并这些有序的子数组以得到最终的有序数组。递归版本中,每次分割区间为[left, mid]和[mid+1, right],确保每两个区间内数据有序后进行合并。非递归版本则通过逐步增加gap值(初始为1),先对单个元素排序,再逐步扩大到更大的区间进行合并,直至整个数组有序。归并排序的时间复杂度为O(n*logn),空间复杂度为O(n),且具有稳定性,适用于普通排序及大文件排序场景。
|
3月前
|
算法 数据处理 C语言
C语言中的位运算技巧,涵盖基本概念、应用场景、实用技巧及示例代码,并讨论了位运算的性能优势及其与其他数据结构和算法的结合
本文深入解析了C语言中的位运算技巧,涵盖基本概念、应用场景、实用技巧及示例代码,并讨论了位运算的性能优势及其与其他数据结构和算法的结合,旨在帮助读者掌握这一高效的数据处理方法。
91 1
|
3月前
|
并行计算 算法 测试技术
C语言因高效灵活被广泛应用于软件开发。本文探讨了优化C语言程序性能的策略,涵盖算法优化、代码结构优化、内存管理优化、编译器优化、数据结构优化、并行计算优化及性能测试与分析七个方面
C语言因高效灵活被广泛应用于软件开发。本文探讨了优化C语言程序性能的策略,涵盖算法优化、代码结构优化、内存管理优化、编译器优化、数据结构优化、并行计算优化及性能测试与分析七个方面,旨在通过综合策略提升程序性能,满足实际需求。
99 1
|
3月前
|
存储 缓存 算法
在C语言中,数据结构是构建高效程序的基石。本文探讨了数组、链表、栈、队列、树和图等常见数据结构的特点、应用及实现方式
在C语言中,数据结构是构建高效程序的基石。本文探讨了数组、链表、栈、队列、树和图等常见数据结构的特点、应用及实现方式,强调了合理选择数据结构的重要性,并通过案例分析展示了其在实际项目中的应用,旨在帮助读者提升编程能力。
99 5
|
3月前
|
存储 算法 搜索推荐
【趣学C语言和数据结构100例】91-95
本文涵盖多个经典算法问题的C语言实现,包括堆排序、归并排序、从长整型变量中提取偶数位数、工人信息排序及无向图是否为树的判断。通过这些问题,读者可以深入了解排序算法、数据处理方法和图论基础知识,提升编程能力和算法理解。
80 4
|
3月前
|
存储 机器学习/深度学习 搜索推荐
【趣学C语言和数据结构100例】86-90
本文介绍并用C语言实现了五种经典排序算法:直接插入排序、折半插入排序、冒泡排序、快速排序和简单选择排序。每种算法都有其特点和适用场景,如直接插入排序适合小规模或基本有序的数据,快速排序则适用于大规模数据集,具有较高的效率。通过学习这些算法,读者可以加深对数据结构和算法设计的理解,提升解决实际问题的能力。
63 4
|
3天前
|
DataX
☀☀☀☀☀☀☀有关栈和队列应用的oj题讲解☼☼☼☼☼☼☼
### 简介 本文介绍了三种数据结构的实现方法:用两个队列实现栈、用两个栈实现队列以及设计循环队列。具体思路如下: 1. **用两个队列实现栈**: - 插入元素时,选择非空队列进行插入。 - 移除栈顶元素时,将非空队列中的元素依次转移到另一个队列,直到只剩下一个元素,然后弹出该元素。 - 判空条件为两个队列均为空。 2. **用两个栈实现队列**: - 插入元素时,选择非空栈进行插入。 - 移除队首元素时,将非空栈中的元素依次转移到另一个栈,再将这些元素重新放回原栈以保持顺序。 - 判空条件为两个栈均为空。
|
1月前
|
存储 C语言 C++
【C++数据结构——栈与队列】顺序栈的基本运算(头歌实践教学平台习题)【合集】
本关任务:编写一个程序实现顺序栈的基本运算。开始你的任务吧,祝你成功!​ 相关知识 初始化栈 销毁栈 判断栈是否为空 进栈 出栈 取栈顶元素 1.初始化栈 概念:初始化栈是为栈的使用做准备,包括分配内存空间(如果是动态分配)和设置栈的初始状态。栈有顺序栈和链式栈两种常见形式。对于顺序栈,通常需要定义一个数组来存储栈元素,并设置一个变量来记录栈顶位置;对于链式栈,需要定义节点结构,包含数据域和指针域,同时初始化栈顶指针。 示例(顺序栈): 以下是一个简单的顺序栈初始化示例,假设用C语言实现,栈中存储
142 77
|
1月前
|
C++
【C++数据结构——栈和队列】括号配对(头歌实践教学平台习题)【合集】
【数据结构——栈和队列】括号配对(头歌实践教学平台习题)【合集】(1)遇到左括号:进栈Push()(2)遇到右括号:若栈顶元素为左括号,则出栈Pop();否则返回false。(3)当遍历表达式结束,且栈为空时,则返回true,否则返回false。本关任务:编写一个程序利用栈判断左、右圆括号是否配对。为了完成本关任务,你需要掌握:栈对括号的处理。(1)遇到左括号:进栈Push()开始你的任务吧,祝你成功!测试输入:(()))
38 7

热门文章

最新文章