【数据结构】二叉树的顺序存储结构 —— 堆2

简介: 【数据结构】二叉树的顺序存储结构 —— 堆

9、取堆顶数据


若堆非空,则取0下标位置数据:


HPDataType HeapTop(HP* php)
{
  assert(php);
  assert(php->size > 0);
  return php->a[0];
}



10、计算堆大小


这就更简单了,直接返回 size


int HeapSize(HP* php)
{
  assert(php);
  return php->size;
}



11、判空


只要 size == 0 ,堆就为空:


bool HeapEmpty(HP* php)
{
  assert(php);
  return php->size == 0;
}



12、打印堆


void HeapPrint(HP* php)
{
  assert(php);
  for (int i = 0; i < php->size; i++)
  {
    printf("%d ", php->a[i]);
  }
  printf("\n");
}





四、完整代码


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 HeapCreate(HP* hp, HPDataType* a, int n);
void HeapPrint(HP* php);
void HeapInit(HP* php);
void HeapDestroy(HP* php);
// 保持他继续是一个堆 O(logN)
void HeapPush(HP* php, HPDataType x);
// 删除堆顶的数据,并且保持他继续是一个堆 O(logN)
void HeapPop(HP* php);
HPDataType HeapTop(HP* php);
int HeapSize(HP* hp);
// 堆的判空
bool HeapEmpty(HP* hp);


Heap.c

#define _CRT_SECURE_NO_WARNINGS 1 
#include "Heap.h"
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->size = php->capacity = 0;
}
// 销毁
void HeapDestroy(HP* php)
{
  assert(php);
  free(php->a);
  php->a = NULL;
  php->size = php->capacity = 0;
}
void Swap(HPDataType* p1, HPDataType* p2)
{
  assert(p1 && p2);
  HPDataType tmp = *p1;
  *p1 = *p2;
  *p2 = tmp;
}
// 向上调整
void AdjustUp(HPDataType* a, int child)
{
  assert(a);
  // 算父亲
  int parent = (child - 1) / 2;
  // 默认小堆
  while (child > 0)
  {
    if (a[child] < a[parent])
    {
      Swap(&a[child], &a[parent]);
      child = parent;
      parent = (child - 1) / 2;
    }
    else
    {
      break;
    }
  }
}
// 保持他继续是一个堆 O(logN)
void HeapPush(HP* php, HPDataType x)
{
  assert(php);
  // 检查容量
  if (php->size == php->capacity)
  {
    int newcapacity = php->capacity == 0 ? 4 : php->capacity * 2;
    HPDataType* tmp = (HPDataType*)realloc(php->a, sizeof(HPDataType) * newcapacity);
    if (tmp == NULL)
    {
      perror("realloc fail");
      exit(-1);
    }
    php->a = tmp;
    php->capacity = newcapacity;
  }
  // 插入元素
  php->a[php->size++] = x;
  // 向上调整
  AdjustUp(php->a, php->size - 1);
}
// 向下调整
void AdjustDown(HPDataType* a, int n, int parent)
{
  // 假设最小孩子
  int minchild = 2 * parent + 1;
  while (minchild < n)
  {
    // 找最小孩子
    if (minchild + 1 < n && a[minchild + 1] < a[minchild])
    {
      minchild++;
    }
    if (a[parent] > a[minchild])
    {
      Swap(&a[parent], &a[minchild]);
      parent = minchild;
      minchild = 2 * parent + 1;
    }
    else
    {
      break;
    }
  }
}
// 删除堆顶的数据,并且保持他继续是一个堆 O(logN)
void HeapPop(HP* php)
{
  assert(php);
  assert(php->size > 0);
  // 交换堆顶和最后一个节点的值
  Swap(&php->a[0], &php->a[php->size - 1]);
  // 尾删
  php->size--;
  AdjustDown(php->a, php->size, 0);
}
HPDataType HeapTop(HP* php)
{
  assert(php);
  assert(php->size > 0);
  return php->a[0];
}
int HeapSize(HP* php)
{
  assert(php);
  return php->size;
}
// 堆的判空
bool HeapEmpty(HP* php)
{
  assert(php);
  return php->size == 0;
}



test.c

#define _CRT_SECURE_NO_WARNINGS 1 
#include "Heap.h"
void TestHp1()
{
  HP hp;
  HeapInit(&hp);
  int arr[] = { 27,15,19,18,28,34,65,49,25,37 };
  int sz = sizeof(arr) / sizeof(arr[0]);
  for (int i = 0; i < sz; i++)
  {
    HeapPush(&hp, arr[i]);
  }
  HeapPrint(&hp);
  HeapPop(&hp);
  HeapPrint(&hp);
    // 取五个最小数据
  /*int k = 5;
  while (k--)
  {
    printf("%d ", HeapTop(&hp));
    HeapPop(&hp);
  }*/
  HeapDestroy(&hp);
}
void TestHp2()
{
  int array[] = { 27, 15, 19, 18, 28, 34, 65, 49, 25, 37 };
  HP hp;
  HeapInit(&hp);
  for (int i = 0; i < sizeof(array) / sizeof(int); ++i)
  {
    HeapPush(&hp, array[i]);
  }
    // 排序
  while (!HeapEmpty(&hp))
  {
    printf("%d ", HeapTop(&hp));
    HeapPop(&hp);
  }
  HeapDestroy(&hp);
}
int main()
{
  TestHp1();
  //TestHp2();
  return 0;
}



到这里,本篇博客就到此结束了。看到这儿,相信大家也对堆有了一定的了解。


今天的内容在二叉树一块还是较简单的。下篇博客我会讲解由堆引申出的两个堆的应用 —— 堆排序 和 TopK问题。所以今天的内容还是很重要的,只有看懂下篇博客理解起来才比较清晰。


如果觉得anduin写的还不错的话,还请一键三连!如有错误,还请指正!


我是anduin,一名C语言初学者,我们下期见!




相关文章
|
1月前
|
存储 算法 Java
散列表的数据结构以及对象在JVM堆中的存储过程
本文介绍了散列表的基本概念及其在JVM中的应用,详细讲解了散列表的结构、对象存储过程、Hashtable的扩容机制及与HashMap的区别。通过实例和图解,帮助读者理解散列表的工作原理和优化策略。
39 1
散列表的数据结构以及对象在JVM堆中的存储过程
|
1月前
|
机器学习/深度学习 存储 算法
数据结构实验之二叉树实验基础
本实验旨在掌握二叉树的基本特性和遍历算法,包括先序、中序、后序的递归与非递归遍历方法。通过编程实践,加深对二叉树结构的理解,学习如何计算二叉树的深度、叶子节点数等属性。实验内容涉及创建二叉树、实现各种遍历算法及求解特定节点数量。
81 4
|
1月前
|
存储 搜索推荐 算法
【数据结构】树型结构详解 + 堆的实现(c语言)(附源码)
本文介绍了树和二叉树的基本概念及结构,重点讲解了堆这一重要的数据结构。堆是一种特殊的完全二叉树,常用于实现优先队列和高效的排序算法(如堆排序)。文章详细描述了堆的性质、存储方式及其实现方法,包括插入、删除和取堆顶数据等操作的具体实现。通过这些内容,读者可以全面了解堆的原理和应用。
75 16
|
1月前
|
C语言
【数据结构】二叉树(c语言)(附源码)
本文介绍了如何使用链式结构实现二叉树的基本功能,包括前序、中序、后序和层序遍历,统计节点个数和树的高度,查找节点,判断是否为完全二叉树,以及销毁二叉树。通过手动创建一棵二叉树,详细讲解了每个功能的实现方法和代码示例,帮助读者深入理解递归和数据结构的应用。
129 8
|
2月前
|
存储 JavaScript 前端开发
为什么基础数据类型存放在栈中,而引用数据类型存放在堆中?
为什么基础数据类型存放在栈中,而引用数据类型存放在堆中?
100 1
|
2月前
|
存储 算法
探索数据结构:分支的世界之二叉树与堆
探索数据结构:分支的世界之二叉树与堆
|
1月前
|
C语言
【数据结构】栈和队列(c语言实现)(附源码)
本文介绍了栈和队列两种数据结构。栈是一种只能在一端进行插入和删除操作的线性表,遵循“先进后出”原则;队列则在一端插入、另一端删除,遵循“先进先出”原则。文章详细讲解了栈和队列的结构定义、方法声明及实现,并提供了完整的代码示例。栈和队列在实际应用中非常广泛,如二叉树的层序遍历和快速排序的非递归实现等。
178 9
|
1月前
|
存储 算法
非递归实现后序遍历时,如何避免栈溢出?
后序遍历的递归实现和非递归实现各有优缺点,在实际应用中需要根据具体的问题需求、二叉树的特点以及性能和空间的限制等因素来选择合适的实现方式。
32 1
|
23天前
|
存储 缓存 算法
在C语言中,数据结构是构建高效程序的基石。本文探讨了数组、链表、栈、队列、树和图等常见数据结构的特点、应用及实现方式
在C语言中,数据结构是构建高效程序的基石。本文探讨了数组、链表、栈、队列、树和图等常见数据结构的特点、应用及实现方式,强调了合理选择数据结构的重要性,并通过案例分析展示了其在实际项目中的应用,旨在帮助读者提升编程能力。
44 5
|
1月前
|
存储 算法 Java
数据结构的栈
栈作为一种简单而高效的数据结构,在计算机科学和软件开发中有着广泛的应用。通过合理地使用栈,可以有效地解决许多与数据存储和操作相关的问题。