目录
- 1. 堆的概念和特点
- 2. 堆的实现
- 2.1 堆向下调整算法
- 2.2堆的创建
- 2.3 建堆时间复杂度
- 2.4 堆的插入
- 2.5 堆的删除
- 2.6 堆的代码实现
- 2.6.1 结构体
- 2.6.2 初始化
- 2.6.3 销毁
- 2.6.4 插入
- 2.6.5 删除
- 2.6.6 获取堆顶
- 2.6.7 判空
- 2.6.8 个数
- 2.6.9 向上调整
- 2.6.10 向下调整
- 3. 堆的实现测试
- 测试1
- 测试2
- 测试3
- 测试4
- 向上调整建堆测试5
- 向下调整建堆测试6
- 4. 堆的应用
- 4.1 堆排序
- 4.2 TOP-K问题
- 5. test.c文件
- 6. Heap.c
- 7. Heap.h
1. 堆的概念和特点
- 定义:
堆通常可以被看作是一棵完全二叉树的数组对象。这意味着堆的物理结构本质上是顺序存储的(线性的),但在逻辑上则表现为完全二叉树的逻辑存储结构。
堆总是满足堆性质:堆中某个结点的值总是不大于(最大堆)或不小于(最小堆)其父结点的值。 - 分类:
根据堆顶元素的大小,堆可以分为最大堆(大根堆)和最小堆(小根堆)。最大堆的根结点值是所有元素中的最大值,而最小堆的根结点值是所有元素中的最小值。
常见的堆类型还包括二叉堆和斐波那契堆等。 - 结构:
堆的物理结构是一维数组,数组的容量和元素个数是堆的重要属性。
在堆中,一个结点的父节点可以通过该结点的索引值整除2得到
2. 堆的实现
2.1 堆向下调整算法
现在我们给出一个数组,逻辑上看做一颗完全二叉树。我们通过从根节点开始的向下调整算法可以把它调整成一个小堆。向下调整算法有一个前提:左右子树必须是一个堆,才能调整。
int array[] = {27,15,19,18,28,34,65,49,25,37};
2.2堆的创建
下面我们给出一个数组,这个数组逻辑上可以看做一颗完全二叉树,但是还不是一个堆,现在我们通过算法,把它构建成一个堆。根节点左右子树不是堆,我们怎么调整呢?这里我们从倒数的第一个非叶子节点的子树开始调整,一直调整到根节点的树,就可以调整成堆。
int a[] = {1,5,3,8,7,6};
2.3 建堆时间复杂度
因为堆是完全二叉树,而满二叉树也是完全二叉树,此处为了简化使用满二叉树来证明(时间复杂度本来看的
就是近似值,多几个节点不影响最终结果):
因此:建堆的时间复杂度为O(N)。
2.4 堆的插入
先插入一个10到数组的尾上,再进行向上调整算法,直到满足堆。
2.5 堆的删除
删除堆是删除堆顶的数据,将堆顶的数据根最后一个数据一换,然后删除数组最后一个数据,再进行向下调整算法。
2.6 堆的代码实现
2.6.1 结构体
typedef int HPDataType;
typedef struct Heap
{
HPDataType* a;
int size;
int capacity;
}HP;
2.6.2 初始化
//初始化
void HeapInit(HP* php)
{
assert(php);
php->a = NULL;
php->capacity = 0;
php->size = 0;
}
2.6.3 销毁
//销毁
void HeapDestroy(HP* php)
{
assert(php);
free(php->a);
php->a = NULL;
php->capacity = 0;
php->size = 0;
}
2.6.4 插入
//插入
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, newCapacity * sizeof(HPDataType));
if (tmp == NULL)
{
perror("HeapPush");
return;
}
php->a = tmp;
php->capacity = newCapacity;
}
//插入数据
php->a[php->size] = x;
php->size++;
//向上调整
AdjustUp(php->a, php->size - 1);
}
2.6.5 删除
//删除堆顶的数据
void HeapPop(HP* php)
{
assert(php);
assert(!HeapEmpty(php));
Swap(&php->a[0], &php->a[php->size - 1]);
php->size--;
AdjustDown(php->a, php->size, 0);
}
2.6.6 获取堆顶
//获取堆顶
HPDataType HeapTop(HP* php)
{
assert(php);
assert(!HeapEmpty(php));
return php->a[0];
}
2.6.7 判空
//判空
bool HeapEmpty(HP* php)
{
assert(php);
return php->size == 0;
}
2.6.8 个数
//个数
int HeapSize(HP* php)
{
assert(php);
return php->size;
}
2.6.9 向上调整
//向上调整
void AdjustUp(HPDataType* a, int child)
{
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;
}
}
}
2.6.10 向下调整
//向下调整
void AdjustDown(int* a, int n, int parent)
{
//假设最小
int child = parent * 2 + 1;
while (child < n)
{
//选出左右孩子小的那个
if (child+1 < n && a[child + 1] < a[child])
{
child++;
}
//不用管哪个最小
if (a[child] < a[parent])
{
Swap(&a[parent], &a[child]);
parent = child;
child = parent * 2 + 1;
}
else
{
break;
}
}
}
3. 堆的实现测试
测试1
//堆的实现测试
void HeapTest1()
{
HP hp;
HeapInit(&hp);
int a[] = { 65,100,70,32,50,60 };
int sz = sizeof(a) / sizeof(a[0]);
for (int i = 0; i < sz; i++)
{
HeapPush(&hp, a[i]);
}
HeapDestroy(&hp);
}
测试2
void HeapTest1()
{
HP hp;
HeapInit(&hp);
int a[] = { 65,100,70,32,50,60 };
int sz = sizeof(a) / sizeof(a[0]);
for (int i = 0; i < sz; i++)
{
HeapPush(&hp, a[i]);
}
HeapPop(&hp);
HeapDestroy(&hp);
}
测试3
void HeapTest1()
{
HP hp;
HeapInit(&hp);
int a[] = { 65,100,70,32,50,60 };
int sz = sizeof(a) / sizeof(a[0]);
for (int i = 0; i < sz; i++)
{
HeapPush(&hp, a[i]);
}
//HeapPop(&hp);
while (!HeapEmpty(&hp))
{
int top = HeapTop(&hp);
printf("%d\n", top);
HeapPop(&hp);
}
HeapDestroy(&hp);
}
测试4
//top-k问题
//方法1:弊端: 先有一个堆太麻烦,空间复杂度高还得拷贝数据。
void HeapSort(int* a, int n)
{
HP hp;
HeapInit(&hp);
for (int i = 0; i < n; i++)
{
HeapPush(&hp, a[i]);
}
int i = 0;
while (!HeapEmpty(&hp))
{
int top = HeapTop(&hp);
a[i++] = top;
HeapPop(&hp);
}
HeapDestroy(&hp);
}
向上调整建堆测试5
void HeapSort2(int* a, int n)
{
//升序-- 建小堆
//降序-- 建大堆
//向上调整建堆
for (int i = 1; i < n; i++)
{
AdjustUp(a, i);
}
//向下调整建堆
/*for (int i = (n - 1 - 1) / 2; i >= 0; --i)
{
AdjustDown(a, n, i);
}*/
int end = n - 1;
while (end > 0)
{
//交换
Swap(&a[0], &a[end]);
//再调整,选出次小的
AdjustDown(a, end, 0);
end--;
}
}
向下调整建堆测试6
//方法2
void HeapSort2(int* a, int n)
{
//升序-- 建小堆
//降序-- 建大堆
//向上调整建堆
/*for (int i = 1; i < n; i++)
{
AdjustUp(a, i);
}*/
//向下调整建堆
for (int i = (n - 1 - 1) / 2; i >= 0; --i)
{
AdjustDown(a, n, i);
}
int end = n - 1;
while (end > 0)
{
//交换
Swap(&a[0], &a[end]);
//再调整,选出次小的
AdjustDown(a, end, 0);
end--;
}
}
4. 堆的应用
4.1 堆排序
堆排序即利用堆的思想来进行排序,总共分为两个步骤:
- 建堆
升序:建大堆
降序:建小堆 - 利用堆删除思想来进行排序
建堆和堆删除中都用到了向下调整,因此掌握了向下调整,就可以完成堆排序。
4.2 TOP-K问题
TOP-K问题:即求数据结合中前K个最大的元素或者最小的元素,一般情况下数据量都比较大。
比如:专业前10名、世界500强、富豪榜、游戏中前100的活跃玩家等。
对于Top-K问题,能想到的最简单直接的方式就是排序,但是:如果数据量非常大,排序就不太可取了(可能
数据都不能一下子全部加载到内存中)。最佳的方式就是用堆来解决,基本思路如下:
- 用数据集合中前K个元素来建堆
前k个最大的元素,则建小堆
前k个最小的元素,则建大堆 - 用剩余的N-K个元素依次与堆顶元素来比较,不满足则替换堆顶元素将剩余N-K个元素依次与堆顶元素比完之后,堆中剩余的K个元素就是所求的前K个最小或者最大的元素。
5. test.c文件
#define _CRT_SECURE_NO_WARNINGS 1
#include"Heap.h"
//堆的实现测试
void HeapTest1()
{
HP hp;
HeapInit(&hp);
int a[] = { 65,100,70,32,50,60 };
int sz = sizeof(a) / sizeof(a[0]);
for (int i = 0; i < sz; i++)
{
HeapPush(&hp, a[i]);
}
//HeapPop(&hp);
while (!HeapEmpty(&hp))
{
int top = HeapTop(&hp);
printf("%d\n", top);
HeapPop(&hp);
}
HeapDestroy(&hp);
}
//top-k问题
//方法1:弊端: 先有一个堆太麻烦,空间复杂度高还得拷贝数据。
void HeapSort(int* a, int n)
{
HP hp;
HeapInit(&hp);
for (int i = 0; i < n; i++)
{
HeapPush(&hp, a[i]);
}
int i = 0;
while (!HeapEmpty(&hp))
{
int top = HeapTop(&hp);
a[i++] = top;
HeapPop(&hp);
}
HeapDestroy(&hp);
}
//方法2
void HeapSort2(int* a, int n)
{
//升序-- 建小堆
//降序-- 建大堆
//向上调整建堆
for (int i = 1; i < n; i++)
{
AdjustUp(a, i);
}
//向下调整建堆
/*for (int i = (n - 1 - 1) / 2; i >= 0; --i)
{
AdjustDown(a, n, i);
}*/
int end = n - 1;
while (end > 0)
{
//交换
Swap(&a[0], &a[end]);
//再调整,选出次小的
AdjustDown(a, end, 0);
end--;
}
}
int main()
{
//HeapTest1();
int a[] = { 7,8,3,5,1,9,5,4 };
HeapSort2(a, sizeof(a) / sizeof(a[0]));
return 0;
}
6. Heap.c
#define _CRT_SECURE_NO_WARNINGS 1
#include "Heap.h"
//初始化
void HeapInit(HP* php)
{
assert(php);
php->a = NULL;
php->capacity = 0;
php->size = 0;
}
//销毁
void HeapDestroy(HP* php)
{
assert(php);
free(php->a);
php->a = NULL;
php->capacity = 0;
php->size = 0;
}
//交换
void Swap(HPDataType* p1, HPDataType* p2)
{
HPDataType tmp = *p2;
*p2 = *p1;
*p1 = tmp;
}
//向上调整
void AdjustUp(HPDataType* a, int child)
{
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;
}
}
}
//插入
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, newCapacity * sizeof(HPDataType));
if (tmp == NULL)
{
perror("HeapPush");
return;
}
php->a = tmp;
php->capacity = newCapacity;
}
//插入数据
php->a[php->size] = x;
php->size++;
//向上调整
AdjustUp(php->a, php->size - 1);
}
//向下调整
void AdjustDown(int* a, int n, int parent)
{
//假设最小
int child = parent * 2 + 1;
while (child < n)
{
//选出左右孩子小的那个
if (child+1 < n && 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 HeapPop(HP* php)
{
assert(php);
assert(!HeapEmpty(php));
Swap(&php->a[0], &php->a[php->size - 1]);
php->size--;
AdjustDown(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;
}
7. Heap.h
#pragma once
#include <stdlib.h>
#include <assert.h>
#include <stdbool.h>
#include <stdio.h>
typedef int HPDataType;
typedef struct Heap
{
HPDataType* a;
int size;
int capacity;
}HP;
//初始化
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);
//向上调整
void AdjustUp(HPDataType* a, int child);
//向下调整
void AdjustDown(int* a, int n, int parent);