目录
1>>导言
上一篇我们讲到了树-二叉树-大小堆，那么这篇来给宝子们实现一下堆的代码，话不多说，直接步入正题吧。请宝子们系好安全带。
2>>堆的结构
是不是很眼熟，嗯？这不就是顺序表吗？是的，堆就是顺序表换了个名字，但是结构，实现代码可大不相同。
接着来看声明部分，这里中文意思都给宝子们标注好了，看完就跟我来实现每一个吧！
3>>堆初始化
首先，还是初始化部分，断言还是一样，判断php是不是一个空指针，然后对arr指针赋值空指针，size和capacity为0
4>>判空和计数
这两个都比较简单就过一下代码即可
5>>堆插入数据
void hppush(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->arr, newcapacity * sizeof(hpdatatype));
if (tmp == NULL) {
perror("realloc");
exit(1);
}
php->arr = tmp;
php->capacity = newcapacity;
}
//扩容结束
//存放数据，每次存放就要比较，以小根堆为例子
//0 1 2 3 size为4，新加入的数据下标为size
php->arr[php->size] = x;
//加入的不一定是与祖先比较大的数，因此需要向上调整
adjustup(php->arr, php->size);
//交换完毕size++
php->size++;
}这里比较多就直接插入代码咯，对于扩容这块，我相信宝子们一定很熟悉了吧， 就不多介绍了，咱们重点来看看向上调整算法！
5.1>>向上调整算法
在上一篇文章，我们学到了parent和child的对应关系，那么继续走，判断条件可以先不写，思考一下：什么时候要交换？
若以小根堆为例子child<parent时就要交换，反之符号调转，然后child和parent都要往上走，判断条件就能知道，当child为0时跳出循环，或者没发生交换跳出循环，因为我们数据全都是新插入的，所以前面都是小根堆，因此没发生交换肯定就是最大的数，此时是小根堆
通过这张图片来帮助宝子们理解，如果插入55，小根堆就要子节点比父节点大，因此交换，child不为0，继续，发现55>10不需要交换，跳出循环。
这个是交换的代码。
6>>删除堆顶数据
删除前面都会，咱们直接来看向下调整算法
6.1>>向下调整算法
向下调整要稍微复杂一丢丢，先不管条件，直接来看循环内部，首先这是一个完全二叉树，有两个孩子结点，需要先找到小的一个，然后在和其父节点进行比较，如果父节点大于孩子结点，那么就往下走，否则退出循环。
7>>取堆顶数据
这个也比较简单，可以根后面的堆排序相辅相成
8>>堆销毁
最后来看看销毁，这里注意先判断arr是否是空指针，不是的话就释放，否则会对空指针解引用，然后跟初始化一样啦。
9>>代码部分
heap.c
#include"heap.h"
void hpinit(HP* php) {
assert(php);
php->arr = NULL;
php->size = php->capacity = 0;
}
bool hpempty(HP* php) {
assert(php);
return php->size==0;
}
int hpsize(HP* php) {
assert(php);
return php->size;
}
void adjustup(hpdatatype* arr, int child) {
//向上调整，parent为（child-1）/2； leftchild为parent*2+1，rightchild为parent*2+2
int parent = (child - 1) / 2;
//为根结点即为0结束
while (child > 0) {
//小根堆<，从上往下每个子孙都比我大
//大根堆>，从上往下每个子孙都比我小
if (arr[child] > arr[parent]) {
//两数交换
swap(&arr[child], &arr[parent]);
//孩子和双亲结点往上走
child = parent;
parent = (child - 1) / 2;
}
else {
break;
}
}
}
void hppush(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->arr, newcapacity * sizeof(hpdatatype));
if (tmp == NULL) {
perror("realloc");
exit(1);
}
php->arr = tmp;
php->capacity = newcapacity;
}
//扩容结束
//存放数据，每次存放就要比较，以小根堆为例子
//0 1 2 3 size为4，新加入的数据下标为size
php->arr[php->size] = x;
//加入的不一定是与祖先比较大的数，因此需要向上调整
adjustup(php->arr, php->size);
//交换完毕size++
php->size++;
}
void adjustdown(hpdatatype* arr, int parent,int size) {
//向下调整，leftchild为parent*2+1，rightchild为parent*2+2
int child = parent * 2 + 1;
//大于等于总结个数n即为size结束
while (child<size) {
//小根堆，从上往下每个子孙都比我大
//大根堆，从上往下每个子孙都比我小
//此时用小根堆
//先要判断左孩子和右孩子哪个更小
if (child + 1 < size && arr[child] > arr[child + 1]) {
child++;
}
//两数交换
//孩子和双亲结点往下走
if (arr[child] < arr[parent])
{
swap(&arr[child], &arr[parent]);
parent = child;
child = parent * 2 + 1;
}
else {
break;
}
}
}
void hppop(HP* php) {
assert(php);
assert(!hpempty(php));
//删除堆顶数据不能直接删除
//否则会大乱套
//思路：根屁股结点互换，然后让新的堆顶向下调整,size--
//屁股为size-1；
swap(&php->arr[0], &php->arr[php->size - 1]);
php->size--;
adjustdown(php->arr,0,php->size);
}
hpdatatype hptop(HP* php) {
assert(php);
return php->arr[0];
}
void swap(int* child, int* parent) {
int tmp = *child;
*child = *parent;
*parent = tmp;
}
void hpdestroy(HP* php) {
assert(php);
assert(!hpempty(php));
if (php->arr)
free(php->arr);
php->arr = NULL;
php->size = php->capacity = 0;
}heap.h
#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<stdbool.h>
#include<assert.h>
#include<time.h>
typedef int hpdatatype;
typedef struct heap {
hpdatatype* arr;
int size;
int capacity;
}HP;
void hpinit(HP* php);//堆初始化
bool hpempty(HP* php);//堆判空
int hpsize(HP* php);//堆计数
void hppush(HP* php, hpdatatype x);//往堆中存放数据
void hppop(HP* php);//删除堆顶数据
hpdatatype hptop(HP* php);//取堆顶数据
void swap(int* child, int* parent);//交换
void adjustdown(hpdatatype* arr, int parent, int size);//向下调整
void hpdestroy(HP* php);//堆销毁
test.c
#define _CRT_SECURE_NO_WARNINGS 1
#include"heap.h"
void test()
{
HP hp;
hpinit(&hp);
hppush(&hp, 1);
hppush(&hp, 2);
hppush(&hp, 4);
hppush(&hp, 5);
hppop(&hp);
hppop(&hp);
hppop(&hp);
hpdestroy(&hp);
}
void test1() {
int arr[] = { 17,20,10,13,19,15 };
int n = sizeof(arr) / sizeof(arr[0]);
HP hp;
hpinit(&hp);
int i = 0;
for (i = 0; i < n; i++) {
hppush(&hp, arr[i]);
}
i = 0;
while (!hpempty(&hp)) {
arr[i++] = hptop(&hp);
hppop(&hp);
}
for (i = 0; i < n; i++) {
printf("%d ", arr[i]);
}
}
void HeapSort(int* arr, int n) {//自己实现堆排序
for (int i =(n-1-1)/2; i >= 0; i--) {
adjustdown(arr, i, n);
}
int end = n - 1;//最后一个结点开始，到0 为止
while (end) {//大根堆
swap(&arr[0], &arr[end]);
adjustdown(arr, 0, end);//end一直--；
end--;
}
//大根堆为升序
}
void CreateNDate()
{
// 造数据
int n = 100000;
srand((unsigned int)time(0));
const char* file = "data.txt";
FILE* fin = fopen(file, "w");
if (fin == NULL)
{
perror("fopen error");
return;
}
for (int i = 0; i < n; ++i)
{
int x = (rand() + i) % 1000000;
fprintf(fin, "%d\n", x);
}
fclose(fin);
}
void TopK()
{
int k = 0;
printf("请输入K：");
scanf("%d", &k);
const char* file = "data.txt";
FILE* fout = fopen(file, "r");
if (fout == NULL)
{
perror("fopen error");
exit(1);
}
//找最大的前K个数，建小堆
int* minHeap = (int*)malloc(sizeof(int) * k);
if (minHeap == NULL)
{
perror("malloc fail!");
exit(2);
}
//读取文件中前K个数据建堆
for (int i = 0; i < k; i++)
{
fscanf(fout, "%d", &minHeap[i]);
}
// 建堆
for (int i = (k - 1 - 1) / 2; i >= 0; i--) {
adjustdown(minHeap, i, k);
}
//要最大就建小堆，要最小就键大堆
int x = 0;
while (fscanf(fout, "%d", &x) != EOF) {
if (x > minHeap[0]) {
minHeap[0] = x;
adjustdown(minHeap, 0, k);
}
}
for (int i = 0; i < k; i++) {
printf("%d ", minHeap[i]);
}
}
int main()
{
/*test();*/
/*test1();*/
/*int arr[] = { 17,20,10,13,19,15 };
int n = sizeof(arr) / sizeof(arr[0]);
HeapSort(arr, n);
int i;
for (i = 0; i < n; i++) {
printf("%d ", arr[i]);
}*/
/*CreateNDate();*/
TopK();
return 0;
}10>>结语
感谢宝子们的支持，今天的分享就到这里，大家下去一定要试试代码噢，看不懂欢迎评论区发问，明天来实现一下堆排序和topk吧~
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
