堆
1.什么是堆
在特殊的树:二叉树-CSDN博客 中我们介绍了完全二叉树,且堆属于完全二叉树这一数据结构,就分类而言,堆只分为大堆、小堆。
大堆:所有的父节点值都大于其子节点值,小堆反之。
2.实现堆及其功能
Heap.h头文件
typedef int HPDataType;
typedef struct Heap
{
HPDataType* _a; //和顺序表一样
int _size;
int _capacity;
}Heap;
//堆的初始化
void HeapInit(Heap* php);
// 堆的销毁
void HeapDestory(Heap* hp);
// 堆的插入
void HeapPush(Heap* hp, HPDataType x);
// 堆的删除
void HeapPop(Heap* hp);
// 取堆顶的数据
HPDataType HeapTop(Heap* hp);
// 堆的数据个数
int HeapSize(Heap* hp);
// 堆的判空
int HeapEmpty(Heap* hp);
void Swap(int* a, int* b);
void Adjustup(Heap* hp, int child);
void Adjustdown(Heap* hp,int parent);
// 对数组进行堆排序
void HeapSort(int* a, int n);
//解决TOPk问题
void CreateNDate();
void PrintTopK(int k);
Heap.c文件:
//堆的初始化
void HeapInit(Heap* php)
{
php->_a = NULL;
php->_size = php->_capacity = 0;
}
// 堆的销毁
void HeapDestory(Heap* hp)
{
assert(hp);
free(hp->_a);
hp->_a = NULL;
hp->_size = hp->_capacity = 0;
}
// 堆的插入
void HeapPush(Heap* hp, HPDataType x)
{
assert(hp);
int newcapacity;
if (hp->_size == hp->_capacity|| hp->_size+1 == hp->_capacity)
{
newcapacity = hp->_capacity == 0 ? 4 : 2 * sizeof(hp->_capacity);
hp->_capacity = newcapacity;
HPDataType* tmp = (HPDataType*)realloc(hp->_a, newcapacity * sizeof(HPDataType));
assert(tmp);
hp->_a = tmp;
}
else
;
hp->_a[hp->_size] = x;
hp->_size++;
Adjustup(hp, hp->_size - 1);
}
// 堆的删除(注意是删除堆顶并重排)
void HeapPop(Heap* hp)
{
assert(hp);
assert(hp->_size > 0);
int end = hp->_size;
Swap(&hp->_a[0], &hp->_a[end-1]);
hp->_size--;
Adjustdown(hp, 0);
}
// 取堆顶的数据
HPDataType HeapTop(Heap* hp)
{
assert(hp);
return hp->_a[0];
}
// 堆的数据个数
int HeapSize(Heap* hp)
{
assert(hp);
return hp->_size;
}
// 堆的判空
int HeapEmpty(Heap* hp)
{
if (hp->_size == 0)
return 1;
else
return 0;
}
//交换数据
void Swap(int* p1, int* p2) //注意传地址
{
int tmp = *p2;
*p2 = *p1;
*p1 = tmp;
}
void Adjustup(Heap* hp,int child) //向上调整,只与其父节点比较,建小堆
{ //一般插入新数据要用
int parent;
parent = (child - 1) / 2;
while (parent>=0)
{
if ((hp->_a[child]) < (hp->_a[parent])) //满足条件则交换(可以是大于号建大堆)
{
Swap(&hp->_a[child], &hp->_a[parent]);
child = parent;
parent = (child - 1) / 2;
}
else
break;
}
}
void Adjustdown(Heap*hp,int parent) //向下调整
{
int leftchild, rightchild;
leftchild = parent * 2 + 1;
rightchild = parent * 2 + 2;
while (leftchild < hp->_size && rightchild < hp->_size) //左右节点都存在
{ //要比较两者大小(永远和最小或最大的交换)
if (hp->_a[leftchild] <= hp->_a[rightchild])
{
if (hp->_a[leftchild] < hp->_a[parent])
{
Swap(&hp->_a[leftchild], &hp->_a[parent]);
parent = leftchild;
leftchild = parent * 2 + 1;
rightchild = parent * 2 + 2;
}
else
break;
}
else if (hp->_a[leftchild] > hp->_a[rightchild])
{
if (hp->_a[rightchild] < hp->_a[parent])
{
Swap(&hp->_a[rightchild], &hp->_a[parent]);
parent = rightchild;
leftchild = parent * 2 + 1;
rightchild = parent * 2 + 2;
}
else
break;
}
}
//右孩子不存在。如果两个都不存在,不用比就结束了
if (leftchild == (hp->_size)-1 )
{
if (hp->_a[leftchild] < hp->_a[parent])
{
Swap(&hp->_a[leftchild], &hp->_a[parent]);
}
else
;
}
}
到此为止,我们已实现了堆的功能。
堆排序
我们以前学过冒泡排序,可以将数组变为有序数组,而堆也是通过数组实现的,并且大堆(小堆)
父子节点数据之间也有大小关系。堆排序也是可以实现数组排序的。
// 对数组进行堆排序
void HeapSort(int* a, int n) //a是数组名,n是数组元素个数
{
Heap A;
HeapInit(&A); //先建堆
A._a = a;
A._size = n ;
for (int i = 0; i < n; i++)
{
Adjustup(&A,i);//将数组中数据依次向上调整建小堆
}
int end = n - 1;
while (end > 0)
{
Swap(&a[0], &a[end]); //交换堆的根数据和未交换的最后一个数据(根数据一定是最小的)
A._size--; //注意堆最后一个数据不要再交换
Adjustdown(&A, 0); //向下调整
end--;
}
}
在每次while循环中,我们都会将小的数据排到后方,依次下来就将数组排好序了。
TOPk问题
从N个数据中选出k个最大(小)的数据。N个数据在txt文件中,此时我们就不能将N个数据放入数组中,因为N个数据是未知且很大的。
void CreateNDate()
{
// 造数据
int n = 20;
srand(time(0));
const char* file = "data.txt";
FILE* fin = fopen(file, "w");
if (fin == NULL)
{
perror("fopen error");
return;
}
for (size_t i = 0; i < n; ++i)
{
int x = rand() % 1000000;
fprintf(fin, "%d\n", x);
}
fclose(fin);
}
void PrintTopK(int k)
{
CreateNDate();
Heap A;
HeapInit(&A);
int m=0;
const char* file = "data.txt";
FILE* fou = fopen(file, "r");
HPDataType* tmp = (HPDataType*)malloc(k*sizeof(int));
A._a = tmp;
for (int j = 0; j < k; j++) //建k个大小的数组,将前k个数放入数组
{
fscanf_s(fou,"%d", &(A._a[j]));
}
A._size = k;
while (m < k)
{
Adjustdown(&A, m); //向下调整,调成小堆
m++;
}
int x = 0;
while (fscanf(fou, "%d", &x)!=-1) //注意fscanf的返回值,0/-1
{
if (x > A._a[0]) //继续读取,比堆顶大的,就交换,再向下调整
{
A._a[0] = x;
Adjustdown(&A, 0);
}
else
;
}
for (int i = 0; i < k; i++)
{
printf("%d ",A._a[i]);
}
fclose(fou);
HeapDestory(&A);
}
总结:介绍堆的功能,用堆将数组排序,N个数中选出k个最大(小)的数。