完全二叉树:假设其深度为h,则除了第h层外,其余层的结点数均饱和,第h层的结点可以饱和可以不饱和(注:满二叉树是一种特别的完全二叉树),且结点总是从左到右连续。
一、堆的本质与分类
堆的本质:是完全二叉树。而在堆中又分为大堆与小堆。
大堆:任意一个结点都比根结点小,即为父结点总是大于其子孙。
小堆:任意一个结点都比根结点大,即为父结点总是小于其子孙。
二、堆的代码实现
堆的结构定义:
typedef int HPDataType;//便于修改存储的数据类型
typedef struct Heap
{
HPDataType* a;
int size; //目前存储的数据个数
int capacity; //数组的容量
}Heap;
堆的构建:
void HeapCreate(Heap* hp)
{
assert(hp);
hp->a = NULL;
hp->size = hp->capacity = 0;
}
堆的销毁:
void HeapDestory(Heap* hp)
{
assert(hp);
free(hp->a);
hp->a = NULL;
hp->size = hp->capacity = 0;
}
堆的向上调整:
(堆的插入处有调整的详细说明)
void AdjustUp(HPDataType* a, int child)
{
int parent = (child - 1) / 2;
while (child > 0)
{
if (a[parent] > a[child])//父亲大于孩子则交换,则会形成父亲小于孩子,建立小堆。
{ //如果建立大堆则用小于号做判断。
//交换两者存储的数据
Swap(&a[parent], &a[child]);
child = parent;
parent = (parent - 1) / 2;
}
else
{
break;
}
}
}
如图可知:
- 父亲结点下标 = (孩子结点下标 - 1)/ 2 (左右孩子均适用)
- 左孩子结点下标 = 父亲结点下标 * 2 + 1
- 右孩子结点下标 = 父亲结点下标 * 2 + 2
堆的向下调整:
void AdjustDown(HPDataType* a, int size, int parent)
{
int child = parent * 2 + 1;//默认为左孩子
while (child < size)
{
if (child + 1 < size && a[child] > a[child + 1])
{
child++; //右孩子存储数据更小且右孩子下标小于size则用右孩子交换
}
if (a[parent] > a[child])//父亲大于孩子则交换,则会形成父亲小于孩子,建立小堆。
{ //如果建立大堆则用小于号做判断。
Swap(&a[parent], &a[child]);
parent = child;
child = parent * 2 + 1;
}
else
{
break;
}
}
}
堆的插入:
void HeapPush(Heap* hp, HPDataType x)
{
//判断是否需要扩容
assert(hp);
if (hp->capacity == hp->size)
{
int newcapacity = hp->capacity == 0 ? 4 : hp->capacity * 2;
//hp->a一开始为NULL,realloc相当于malloc
HPDataType* tmp = (HPDataType*)realloc(hp->a, sizeof(HPDataType) * newcapacity);
if (tmp == NULL)
{
perror("realloc failure");
exit(-1);
}
//tmp防止realloc开辟空间失败NULL覆盖a存储的地址
hp->a = tmp;
hp->capacity = newcapacity;
}
//扩容完成,存储数据
hp->a[hp->size++] = x;
AdjustUp(hp->a, hp->size - 1);
}
堆的删除:
直接删除根结点会有很多问题,这里选择与最后一个结点交换再删除最后一个结点,最后从根结点开始进行向下调整,保证该结构仍是堆。
void HeapPop(Heap* hp)
{
assert(hp);
assert(hp->size > 0);
Swap(&hp->a[0], &hp->a[hp->size - 1]);
hp->size--; //size--会使下次插入会覆盖最后一个数据,相当于删除了
AdjustDown(hp->a, hp->size, 0);
}
三、堆排序
堆排序,其时间复杂度为O(N*logN),空间复杂度为O(1)
实现思路
主要分为以下两个步骤:
- 通过向下调整或向上调整来进行建堆(至于要建大堆还是小堆就得看你想要升序还是降序了)
- 建立大堆后(小堆),a[0]处就是该数组的最大值(最小值),然后将a[0]与a[end](end初值等于n-1)交换完后再通过调整维持元素下标小于end的大堆结构,这样可以从剩下的元素中选最大。最后反复筛选最大值(最小值),并将其置于end。
思路概括: 通过大堆(小堆)选出最大(最小)值,并放到下标为end的位置,然后选出次大(次小)重复以上操作,直到end等于0。
void AdjustDown(int* a, int size, int parent)
{
int child = parent * 2 + 1;
while (child < size)
{
if (child + 1 < size && a[child] < a[child + 1])
{
child++;
}
if (a[parent] < a[child])
{
Swap(&a[parent], &a[child]);
parent = child;
child = parent * 2 + 1;
}
else
{
break;
}
}
}
void HeapSort(int* a, int n)
{
assert(a);
//通过向下调整建立大堆,为什么i从(n-2)/2开始,请看下图
for (int i = (n - 2) / 2; i >= 0; i--)
{
AdjustDown(a, n, i);
}
//进行排序,并维持元素下标小于end的大堆结构,这样可以从剩下的元素中选最大
int end = n - 1;
while (end > 0)
{
Swap(&a[0], &a[end]);
AdjustDown(a, end, 0);
--end;
}
}
向下调整建堆注意事项
为什么i从(n-2)/2开始?
首先向下调整的前提是该结点得有子结点,所以从最后一个结点的父结点开始,而父亲结点下标 = (孩子结点下标 - 1)/ 2 ,所以最后一个父亲结点下标就是((n-1)-1)/2。