目录

一.堆的概念及结构

二.接口实现

A.初始化  Heapinit   销毁 Heapdestroy

B.插入 Heappush 向上调整  AdjustUp

1.Heappush

2.AdjustUp

C.删除 Heappop  向下调整  AdjustDown

D.堆的判空  Heapempty  堆顶数据  Heaptop  堆的大小  Heapsize

三.源码

Heap.h

Heap.c

test.c

一.堆的概念及结构

1.概念

     如果有一个关键码的集合K = { ， ， ，…， }，把它的所有元素按完全二叉树的顺序存储方式存储在一个一维数组中，并满足： <= 且 <= ( >= 且 >= ) i = 0，1，2…，则称为小堆(或大堆)。将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。
2.堆的性质：
    A.堆中某个节点的值总是不大于或不小于其父节点的值；
    B.堆总是一棵完全二叉树。

其实堆是一种二叉树，通常我们都是用数据表实现，也就是说堆的底层是数组，数组中的小标表示二叉树的节点，所以在实现堆之前，我们有必要了解完全二叉树中节点之间的关系。

1.理解父节点 parent 和子节点 child；

2.了解父节点与子节点之间的关系：

   A.parent=（child-1）/2；

   B.左孩子child=2*parent+1；

   C.右孩子child=2*parent+2。

二.接口实现

A.初始化  Heapinit   销毁 Heapdestroy

这里的初始化和销毁都很简单，相信这对学到堆的人并不是什么难事，和顺序表的操作是一样的，如果实在不理解的话，请看 ->  顺序表

B.插入 Heappush 向上调整  AdjustUp

1.Heappush

插入数据很简单，直接对数组赋值，然后 size 再加加就行了，但是在插入完数据后，我们得保证它是堆，所以这就需要用到向上调整这个函数。

2.AdjustUp

假设我们建的是大堆，我们将新插入的节点与它的父节点比较：

1.如果比它的父节点大，则与其交换，所以交换后的父节点就成为了子节点，再与其父节点比较，以此类推；

2.如果child<=0 则结束循环。

void Swap(HPdatatype* p1, HPdatatype* p2)  //交换函数
{
HPdatatype tmp = *p1;
*p1 = *p2;
*p2 = tmp;
}
 
void AdjustUp(HPdatatype* arr, int child)   //向上调整
{
assert(arr);
 
int parent = (child - 1) / 2;
 
while (child > 0)
{
if (arr[child] > arr[parent])
{
Swap(&arr[child], &arr[parent]);
child = parent;
parent = (child - 1) / 2;
}
else
break;
}
}
 
void Heappush(Heap* php, HPdatatype x)
{
assert(php);
 
if (php->size == php->capacity)
{
HPdatatype* tmp = (HPdatatype*)realloc(php->arr, 2 * sizeof(HPdatatype) * php->capacity);
if (tmp == NULL)
{
perror("realloc fail");
exit(-1);
}
 
php->arr = tmp;
php->capacity *= 2;
}
 
php->arr[php->size] = x;
php->size++;
 
AdjustUp(php->arr, php->size - 1);  //注意这里要传size-1，因为size表示的是下一个位置
}

C.删除 Heappop  向下调整  AdjustDown

1.删除的话，我们是要删除堆顶的数据，因为删除堆尾的数据并没有什么实际意义，删除就是让size--，但是堆顶数据的下标是0，所以在删除前应先交换堆顶和堆尾的数据；

2.删除完后，还要保持它还是个堆，不能把后面的顺序搞乱了，要想达到这个目的，就需要使用到向下调整这个函数；

3.假设是大堆，向下调整是父节点与其较大的子节点比较，如果较大的那个子节点大于父节点，则二者交换，然后较大的子节点成为了新的父节点，当子节点的下标大于或是等于节点总数，也就是size时，就结束循环。

 

D.堆的判空  Heapempty  堆顶数据  Heaptop  堆的大小  Heapsize

这些接口的实现都非常简单，博主就不在这里讲述了，可以参考后面的源码。

三.源码

Heap.h

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <stdbool.h>
#include <time.h>
 
#define MAX_MIN <   //通过改变这里的符号，可以决定是建大堆还是小堆
 
typedef int HPdatatype;
 
typedef struct Heap
{
HPdatatype* arr;
int size;
int capacity;
}Heap;
 
void Heapinit(Heap* php);
 
void Swap(HPdatatype* p1, HPdatatype* p2);
 
void AdjustUp(HPdatatype* arr, int child);  //向上调整
 
void Heappush(Heap* php, HPdatatype x);
 
void AdjustDown(HPdatatype* arr, int parent, int n);  //向下调整
 
void Heappop(Heap* php);
 
HPdatatype Heaptop(Heap* php);
 
int Heapsize(Heap* php);
 
bool Heapempty(Heap* php);
 
void Heapdestroy(Heap* php);

Heap.c

#include "Heap.h"
 
 
void Heapinit(Heap* php)
{
assert(php);
 
php->arr = (HPdatatype*)malloc(sizeof(HPdatatype) * 4);
if (php->arr == NULL)
{
perror("malloc fail");
exit(-1);
}
php->size = 0;
php->capacity = 4;
}
 
void Swap(HPdatatype* p1, HPdatatype* p2)
{
HPdatatype tmp = *p1;
*p1 = *p2;
*p2 = tmp;
}
 
///С
 
void AdjustUp(HPdatatype* arr, int child)
{
assert(arr);
 
int parent = (child - 1) / 2;
 
while (child > 0)
{
if (arr[child] MAX_MIN arr[parent])
{
Swap(&arr[child], &arr[parent]);
child = parent;
parent = (child - 1) / 2;
}
else
break;
}
}
 
void Heappush(Heap* php, HPdatatype x)
{
assert(php);
 
if (php->size == php->capacity)   //插入前，判断数组是否已满
{
HPdatatype* tmp = (HPdatatype*)realloc(php->arr, 2 * sizeof(HPdatatype) * php->capacity);
if (tmp == NULL)
{
perror("realloc fail");
exit(-1);
}
 
php->arr = tmp;
php->capacity *= 2;
}
 
php->arr[php->size] = x;
php->size++;
 
AdjustUp(php->arr, php->size - 1);  //这里要传size-1
}
 
void AdjustDown(HPdatatype* arr, int parent, int n)
{
assert(arr);
 
int child = 2 * parent + 1;
 
while (child < n)
{
        //判断较大（较小）的子节点
if ((child + 1) < n && arr[child + 1] MAX_MIN arr[child])  
{
child++;
}
 
if (arr[child] MAX_MIN arr[parent])
{
Swap(&arr[child], &arr[parent]);
parent = child;
child = 2 * parent + 1;
}
else
break;
}
}
 
void Heappop(Heap* php)
{
assert(php);
assert(php->size);
Swap(&php->arr[0], &php->arr[php->size - 1]);
php->size--;
 
AdjustDown(php->arr, 0, php->size);
}
 
HPdatatype Heaptop(Heap* php)
{
assert(php);
assert(php->size);   //为空时不能取数据
 
return php->arr[0];
}
 
int Heapsize(Heap* php)
{
assert(php);
 
return php->size;
}
 
bool Heapempty(Heap* php)
{
assert(php);
 
return php->size == 0;  //size==0即为空
}
 
void Heapdestroy(Heap* php)
{
assert(php);
free(php->arr);
php->arr = NULL;
php->size = 0;
php->capacity = 0;
}

test.c

#include "Heap.h"
 
 
void testHeap()
{
Heap hp;
Heapinit(&hp);
 
int i = 0, n = 10;
int x = 0;
while (n)
{
x = rand() % 100 + 1;
 
Heappush(&hp, x);
n--;
}
while (!Heapempty(&hp))
{
printf("%d  ", Heaptop(&hp));
Heappop(&hp);
}
 
printf("\n");
Heapdestroy(&hp);
}
 
int main()
{
srand((unsigned int)time(NULL));
testHeap();
 
return 0;
}

🐲👻这循环队列的讲解就到这里了，若有错误或是建议欢迎小伙伴们指出。🐯🤖

🥰🤩希望小伙伴们可以多多支持博主哦。😍😃

😁😄谢谢你的阅读。😼😸