【数据结构】二叉树——堆
目录
1 二叉树的存储结构
1.1 顺序存储
2 二叉树的顺序结构及实现
2.1 二叉树的顺序结构
2.2 堆的概念及结构
2.3 堆的实现
2.3.1堆向下调整算法
2.3.2堆的上调算法
2.3.3堆的创建
2.3.4建堆时间复杂度
2.3.5堆的插入
2.3.6堆的删除
2.3.7堆的代码实现
3 堆的应用
3.1堆排序
3.2 TopK问题
test.c文件
Heap.h文件
Heap.c文件
1 二叉树的存储结构
1.1 顺序存储
顺序结构存储就是使用数组来存储，一般使用数组只适合表示完全二叉树，因为不是完全二叉树会有空 间的浪费。而现实中使用中只有堆才会使用数组来存储。二叉树顺序存储在物理上是一个数组，在逻辑上是一颗二叉树。
1.2 链式存储
二叉树的链式存储结构是指，用链表来表示一棵二叉树，即用链来指示元素的逻辑关系。 通常的方法是 链表中每个结点由三个域组成，数据域和左右指针域，左右指针分别用来给出该结点左孩子和右孩子所 在的链结点的存储地址 。链式结构又分为二叉链和三叉链.
typedef int BTDataType;
// 二叉链
struct BinaryTreeNode
{
struct BinTreeNode* _pLeft; // 指向当前节点左孩子
struct BinTreeNode* _pRight; // 指向当前节点右孩子
BTDataType _data; // 当前节点值域
}；
// 三叉链
struct BinaryTreeNode
{
struct BinTreeNode* _pParent; // 指向当前节点的双亲
struct BinTreeNode* _pLeft; // 指向当前节点左孩子
struct BinTreeNode* _pRight; // 指向当前节点右孩子
BTDataType _data; // 当前节点值域
}；2 二叉树的顺序结构及实现
2.1 二叉树的顺序结构
普通的二叉树是不适合用数组来存储的，因为可能会存在大量的空间浪费。而完全二叉树更适合使用顺序结构存储。现实中我们通常把堆(一种二叉树)使用顺序结构的数组来存储。
（需要注意的是这里的堆和操作系统虚拟进程地址空间中的堆是两回事，一个是数据结构，一个是操作系统中管理内存的一块区域分段）
2.2 堆的概念及结构
在数据结构中，堆是一种特殊的树形数据结构，它具有以下两个特点：
1. 堆是一棵完全二叉树，即除了最后一层节点不满外，其他层节点都是满的。
2. 堆中每个节点的值都必须满足某种特定的条件。在最大堆中，父节点的值必须大于等于其子节点的值，在最小堆中则相反。
最大堆：树中所有父亲节点的值始终大于等于其孩子节点的值，如下图所示。
最小堆：树中所有父亲节点的值始终小于等于其孩子节点的值，如下图所示。
（堆总是一颗完全二叉树）
上图大堆的物理存储结构：
1.孩子和父亲下标的关系：
leftchild = parent * 2 +1
rightchild = parent *2 +2
parent = (child - 1) / 2
2.任何一个数组，看作完全二叉树，但不一定是堆
2.3 堆的实现
2.3.1堆向下调整算法
堆排序和优先队列等算法都要使用堆这种数据结构。在这些算法中，我们需要将一个无序集合重新构建成满足堆性质的堆。下调操作是实现这个过程中非常重要的一步。
下调操作（也叫做“下沉”或“下移”）是指将某个元素从树的根部往下移动，直到其找到一个适当的位置以满足堆性质。下调操作通常发生在删除最大（或最小）元素时。具体操作步骤如下：
1. 将要删除的元素替换为堆中最后一个元素。
2. 对替换后的元素进行下沉操作（从上往下移动），直到该元素在其子树中找到正确位置。
3. 重复执行第2步，直到整个二叉树重新满足堆的特性。
具体下沉操作的实现方式要根据堆的类型和语言的不同而有所变化。以最大堆为例，我们可以使用以下算法来实现下调操作，代码中`a`为数组表示的堆：
void AdjustDown(HPDataType* a, int n, int parent) //此处的parent表示parent的下标，n表示数组大小
{
//assert(a);
int child = parent * 2 + 1; //左孩子
while (child < n)
{
//确认child指向小的那个孩子
if (child + 1 < n && a[child + 1] > a[child]) //这里的child+1 < n表示是否有右孩子，如果没有的话，a[child+1]会越界访问，所以加上child + 1 < n 这个条件
{
++child;
}
//1、孩子大于父亲，交换，继续向下调整
//2、孩子小于父亲，则调整结束
if (a[child] < a[parent])
{
Swap(&a[child], &a[parent]);
parent = child; //更新位置
child = parent * 2 + 1; //更新位置
}
else
{
break;
}
}
}
这个算法时间复杂度是O(log n)，其中n是堆中的元素数量。通过使用这个算法重构堆，我们可以保证每次删除最大元素时能够得到正确的结果。
2.3.2堆的上调算法
堆的上调操作（也叫做“上浮”或“上移”）是指将一个新元素插入到堆的末尾，并将其移动到正确的位置以满足堆的特性。具体操作步骤如下：
1. 将新元素插入到堆的最后一个位置。
2. 比较新元素和其父节点的值。如果新元素比其父节点大（在最大堆中）或者小（在最小堆中），则交换它们的值。
3. 重复执行第2步，直到整个二叉树重新满足堆的特性。
具体上浮操作的实现方式要根据堆的类型和语言的不同而有所变化。以最大堆为例，我们可以使用以下算法来实现上调操作，代码中`a`为数组表示的堆：
void AdjustUp(HPDataType* a, int child) //此处的child 参数表示为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;
}
}
}
这个算法时间复杂度也是O(log n)，其中n是堆的元素数量。通过使用这个算法插入新元素，我们可以保证每次操作后整个二叉树满足堆的特性。
2.3.3堆的创建
给出一个数组，可以看作一颗完全二叉树，但还不是一个堆。现在我们通过算法，把它构建成一个堆。根节点左右子树不是堆，我们怎么调整呢？这里我们从倒数的第一个非叶子节点的子树开始调整，一直调整到根节点的树，就可以调整成堆
int array[] = {27,15,19,18,28,34,65,49,25,37};
此时可以看出它还不是一个堆，则需要调整为一个堆。这里建堆的思想是向下调整算法，从最后一个节点的父亲节点开始调整。如图
以大堆为例，调整第1个时，37和28对比，37大，则37的位置和28交换，继续调整下一个节点，直到调整到根节点为止。这里的最后一个节点的父亲节点的下标为， (n-1 -1) / 2 ,如图：
堆的创建代码如下：
typedef int HPDataType;
typedef struct Heap
{
HPDataType* _a;
int _size;
int _capacity;
}Heap;
void HeapCreate(Heap* hp, HPDataType* a, int n)
{
assert(hp);
assert(a);
hp->_a = (HPDataType*)malloc(sizeof(HPDataType)*n);
if (hp->_a == NULL)
{
perror("malloc fail");
exit(-1);
}
hp->_size = hp->_capacity = n;
// memcpy(hp->_a, a, sizeof(HPDataType) * n); //将数组的值复制过来
for (int i = 0; i < n; ++i)
{
hp->_a[i] = a[i];
}
//建堆算法
for (int i = (n - 1 - 1) / 2; i >= 0; --i) //从最后一个节点的父亲节点(n-1-1)/2开始调用下调算法
{
AdjustDown(hp->_a, hp->_size, i);
}
}2.3.4建堆时间复杂度
1 向下调整算法建堆
该建堆方式是从倒数第二层开始建堆，考虑最坏的结果：倒数第二层有2^(h-2)个节点,每个节点调整一次，有2^(h-2 ) * 1;倒数第三层有 2^(h-3) 个节点，每个节点调整 2次，则2^(h-3) *2。
调整次数 F(h) = 2^(h-2) *1 + 2^(h-3) *2 +……+2^1 *(h-2) + 2^0 * (h-1);
2F(h)=2^(h-1)*1 + 2^(h-2)*2 + 2^(h-3) *3 +……+2^2*(h-2) + 2^1*(h-1)
2F(h) - F(h) = 2^(h-1) + 2^ (h-2) + ……+ 2^2 + 2^1 -(h-1) = 2 ^h -1 -h
由2 ^ h -1 = N 得 F(N) = N - logN ;(N是节点数，h 为树得深度)
所以向下调整算法建堆的时间复杂度为O(N)
2 向上调整算法建堆时间复杂度
该建堆方式是从根节点开始，然后一个个的插入堆的末尾，向上进行调整。
F(h) = 0 + 2^1 *1 + 2^2 *2 + …… + 2^(h-2)*(h-2) + 2^(h-1) * (h-1)
直接看最后的一项，可以看出，向上调整算法建堆的时间复杂度为N *logN
2.3.5堆的插入
先插入一个元素到数组的尾上，再进行向上调整算法，直到满足堆。操作如下：
1.先将元素插入到堆的末尾，即最后一个孩子之后
2 插入之后如果堆的性质被破坏，则将插入节点顺着双亲向上调整到合适位置。
例如插入一个元素’10‘。
void HeapPush(Heap* hp, HPDataType x)
{
assert(hp);
//扩容
if (hp->_capacity == hp->_size)
{
int newCapacity = hp->_capacity == 0 ? 4 : hp->_capacity * 2; //扩容
HPDataType* tmp = (HPDataType*)realloc(hp->_a, sizeof(HPDataType) * newCapacity);
if (tmp == NULL)
{
perror("realloc fail");
exit(-1);
}
hp->_capacity = newCapacity;
hp->_a = tmp;
}
hp->_a[hp->_size]=x; //尾插
hp->_size++;
AdjustUp(hp->_a, hp->_size - 1);
}2.3.6堆的删除
删除堆是删除堆顶的数据，将堆顶的数据和最后一个数据一换，然后删除数组最后一个数据，再进行向下调整算法。
void AdjustDown(HPDataType* a, int n, int parent)
{
int child = parent * 2 + 1; //左孩子
while (child < n) //数组是半开区间[0,n)
{
if (child + 1 < n && a[child + 1] > a[child]) //这里child+1表示右孩子
{
++child;
}
//1、孩子大于父亲，交换，继续向下调整
//2、孩子小于父亲，break
if (a[child] > a[parent])
{
Swap(&a[child], &a[parent]);
parent = child; //更新父亲的下标
child = parent * 2 + 1; //再次找到这更新之后的节点之后的下标
}
else
{
break;
}
}
}2.3.7堆的代码实现
#include
#include
#include
typedef int HPDataType;
typedef struct Heap
{
HPDataType* _a;
int _size;
int _capacity;
}Heap;
// 堆的构建
void HeapCreate(Heap* hp, HPDataType* a, int n);
// 堆的销毁
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(HPDataType* x1, HPDataType* x2)
{
HPDataType x = *x1;
*x1 = *x2;
*x2 = x;
}
void AdjustDown(HPDataType* a, int n, int root)
{
int parent = root;
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[child], &a[parent]);
parent = child;
child = parent*2+1;
}
else
{
break;
}
}
}
void AdjustUp(HPDataType* a, int n, int child)
{
int parent;
assert(a);
parent = (child-1)/2;
//while (parent >= 0)
while (child > 0)
{
//如果孩子大于父亲，进行交换
if (a[child] > a[parent])
{
Swap(&a[parent], &a[child]);
child = parent;
parent = (child-1)/2;
}
else
{
break;
}
}
}
void HeapInit(Heap* hp, HPDataType* a, int n)
{
int i;
assert(hp && a);
hp->_a = (HPDataType*)malloc(sizeof(HPDataType)*n);
hp->_size = n;
hp->_capacity = n;
for (i = 0; i < n; ++i)
{
hp->_a[i] = a[i];
}
// 建堆： 从最后一个非叶子节点开始进行调整
// 最后一个非叶子节点，按照规则： （最后一个位置索引 - 1） / 2
// 最后一个位置索引： n - 1
// 故最后一个非叶子节点位置： (n - 2) / 2
for(i = (n-2)/2; i >= 0; --i)
{
AdjustDown(hp->_a, hp->_size, i);
}
}
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);
//检查容量
if (hp->_size == hp->_capacity)
{
hp->_capacity *= 2;
hp->_a = (HPDataType*)realloc(hp->_a, sizeof(HPDataType)*hp->_capacity);
}
//尾插
hp->_a[hp->_size] = x;
hp->_size++;
//向上调整
AdjustUp(hp->_a, hp->_size, hp->_size-1);
}
void HeapPop(Heap* hp)
{
assert(hp);
//交换
Swap(&hp->_a[0], &hp->_a[hp->_size-1]);
hp->_size--;
//向下调整
AdjustDown(hp->_a, hp->_size, 0);
}
HPDataType HeapTop(Heap* hp)
{
assert(hp);
return hp->_a[0];
}
int HeapSize(Heap* hp)
{
return hp->_size;
}
int HeapEmpty(Heap* hp)
{
return hp->_size == 0 ? 0 : 1;
}
void HeapPrint(Heap* hp)
{
int i;
for (i = 0; i < hp->_size; ++i)
{
printf("%d ", hp->_a[i]);
}
printf("\n");
}
3 堆的应用
3.1堆排序
堆排序即利用堆的思想来进行排序，总共分为两个步骤：
1 建堆
升序：建大堆
降序：建小堆
2 利用堆思想进行排序
建堆和堆删除中都用到了向下调整，因此掌握了向下调整，就可以完成堆排序。
假如，升序的时候建小堆，那么出数据的时候，会使得堆的性质发生改变，需要重新建堆。如图
而如果建的是大堆，那么只需要将第一个数据和最后一个数据交换位置，然后将最后一个数据不看做堆里面的，再选出次大的，再交换，依次类推；如图
然后数组的数据最终为升序：[15,18,19,25,27,28,34,37,49,65].
3.2 TopK问题
TOP-K问题：即求数据结合中前K个最大的元素或者最小的元素，一般情况下数据量都比较大。
比如：专业前10名、世界500强、富豪榜、游戏中前100的活跃玩家等。
对于Top-K问题，能想到的最简单直接的方式就是排序，但是：如果数据量非常大，排序就不太可取了(可能 数据都不能一下子全部加载到内存中)。最佳的方式就是用堆来解决，基本思路如下：
1 用数据集合中前K个元素来建堆
求前k个最大的元素，则建小堆
求前k个最小的元素，则建大堆
2. 用剩余的N-K个元素依次与堆顶元素来比较，不满足则替换堆顶元素
将剩余N-K个元素依次与堆顶元素比完之后，堆中剩余的K个元素就是所求的前K个最小或者最大的元素。
这里用文件存储随机数据，再从文件中读出数据用堆排序进行选择前k个最大的数据。代码如下(将Heap.h 、Heap.c 和 test.c三个文件放在一起执行)：
test.c文件
#include"Heap.h"
#include
void TestHeap5()
{
//造数据
int n, k;
printf("请输入n和k:>");
scanf("%d%d", &n, &k);
srand(time(0)); //添加一个时间搓，使得每次7运行程序时的数字排序是不一样的。
FILE* fin = fopen("data.txt", "w");
if (fin == NULL)
{
perror("fopen fail");
return;
}
int ranK = k;
for (size_t i = 0; i < n; ++i)
{
int val = rand() % 100000;
fprintf(fin, "%d\n", val);
}
fclose(fin);
//找topK///
FILE* fout = fopen("data.txt", "r");
if (fout == NULL)
{
perror("fopen fail");
return;
}
//int minHeap[5]
int* minHeap = malloc(sizeof(int) * k);
if (minHeap == NULL)
{
perror("malloc fail");
exit(-1);
}
for (int i = 0; i < k; ++i)
{
fscanf(fout, "%d", &minHeap[i]);
}
//建小堆
for (int i = (k - 1 - 1) / 2; i >= 0; --i)
{
AdjustDown(minHeap, k, i);
}
int val = 0;
while (fscanf(fout, "%d", &val) != EOF)
{
if (val > minHeap[0])
{
minHeap[0] = val;
AdjustDown(minHeap, k, 0);
}
}
for (int i = 0; i < k; ++i)
{
printf("%d ", minHeap[i]);
}
printf("\n");
fclose(fout);
}
int main()
{
TestHeap5();
return 0;
} Heap.h文件
#pragma once
#include
#include
#include
#include
#include
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);
//删除堆顶的数据,并且保持他继续是一个堆0(logN)
void HeapPop(HP* php);
HPDataType HeapTop(HP* php);
int HeapSize(HP* hp);
//堆的判空
bool HeapEmpty(HP* hp); Heap.c文件
#define _CRT_SECURE_NO_WARNINGS
#include"Heap.h"
//堆的构建
//void HeapCreate(HP* php, HPDataType* a, int n)
//{
// assert(php);
// HeapInit(php);
// for (int i = 0; i < n; ++i)
// {
// HeapPush(php, a[i]);
// }
//}
void Swap(HPDataType* p1, HPDataType* p2);
void AdjustDown(HPDataType* a, int n, int parent);
void Swap(HPDataType* p1, HPDataType* p2)
{
HPDataType tmp = *p1;
*p1 = *p2;
*p2 = tmp;
}
void AdjustDown(HPDataType* a, int n, int parent) //此处的parent表示parent的下标
{
//assert(a);
int child = parent * 2 + 1; //左孩子
while (child < n)
{
//确认child指向小的那个孩子
if (child + 1 < n && a[child + 1] > a[child])
{
++child;
}
//1、孩子大于父亲，交换，继续向下调整
//2、孩子小于父亲，则调整结束
if (a[child] > a[parent])
{
Swap(&a[child], &a[parent]);
parent = child; //更新位置
child = parent * 2 + 1; //更新位置
}
else
{
break;
}
}
}
//void HeapCreate(HP* php, HPDataType* a, int n)
//{
// assert(php);
// php->a = (HPDataType*)malloc(php->a, sizeof(HPDataType) * n);
// if (php->a == NULL)
// {
// perror("malloc fail");
// exit(-1);
// }
// memcpy(php->a, a, sizeof(HPDataType) * n);
// php->size = php->capacity = n;
// //建堆算法
// for (int i = (n - 1 - 1) / 2; i >= 0; --i)
// {
// AdjustDown(a, n, i);
// }
//}
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->capacity = php->size = 0;
}
void AdjustUp(HPDataType* a, int child) //此处的child 参数表示为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, sizeof(HPDataType) * newCapacity);
if (tmp == NULL)
{
perror("realloc fail");
exit(-1);
}
php->a = tmp;
php->capacity = newCapacity;
}
php->a[php->size] = x; //尾插
php->size++;
AdjustUp(php->a, php->size - 1);
}
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;
}运行截图：
