朋友们、伙计们，我们又见面了，本期来给大家解读一下栈和队列方面的相关知识点，如果看完之后对你有一定的启发，那么请留下你的三连，祝大家心想事成！

数据结构与算法专栏：数据结构与算法

个人主页 ：stackY、

C 语言专栏：C语言：从入门到精通

前言：

1.堆的应用：堆排序

1.1直接使用堆进行插入

1.2向上调整算法建堆

1.3向下调整算法建堆

2.算法时间复杂度

2.1向下调整建堆算法时间复杂度

2.2向上调整建堆的时间复杂度

3.堆排序的时间复杂度

4.完整堆排序代码

前言：

通过前面的学习和了解我们了解到了二叉树使用顺序结构实现的方式为堆，并且对堆的实现都做了详细的介绍，那么本期我们来看看堆到底都有哪些应用场景呢？

堆这个数据结构我们经常使用它来进行堆排序和解决Top-K的问题，本期我们先来重点的了解堆是怎么进行排序的呢？

1.堆的应用：堆排序

前面我们讲到过冒泡排序和qsort排序，那么本期再来一种新的排序算法，它的效率也是蛮高的。它所要用到的相关知识点就是数据结构：堆

实现堆排序这里有三种思路：

1. 直接将数组插入到堆中，然后再将堆中的数据插入到数组中。

2. 向上调整算法建堆，然后使用堆删除的思想来排序。

3. 向下调整算法建堆，然后使用堆删除的思想来排序。

1.1直接使用堆进行插入

先创建一个堆，然后将数组中的元素依次插入到堆中，如果是大堆在插入完之后就排序成了降序，然后将堆中的数据依次拷贝到数组中，这样子就完成了排序。

代码演示：

//    堆

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <stdbool.h>

//创建堆
//顺序表
typedef int HPDataType;

typedef struct Heap
{
	HPDataType* a;
	int size;  //有效元素个数
	int capacity;  //容量
}Heap;

//初始化
void HeapInit(Heap* php);

//销毁
void HeapDestroy(Heap* php);

//插入
void HeapPush(Heap* php, HPDataType x);

//删除
void HeapPop(Heap* php);

//判空
bool HeapEmpty(Heap* php);

//获取堆顶元素
HPDataType HeapTop(Heap* php);

//初始化
void HeapInit(Heap* php)
{
	php->a = NULL;
	php->size = 0;
	php->capacity = 0;
}

//销毁
void HeapDestroy(Heap* php)
{
	free(php->a);
	php->a = NULL;
	php->size = php->capacity = 0;
}

//交换函数
void Swap(HPDataType* p1, HPDataType* p2)
{
	HPDataType tmp = *p1;
	*p1 = *p2;
	*p2 = 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(Heap* php, HPDataType x)
{
	assert(php);
	//插入数据的过程
	//容量不够则需要扩容
	//判断空间是否不足
	if (php->size == php->capacity)
	{
		int newcapacity = php->capacity == 0 ? 4 : 2 * php->capacity;
		//为堆开辟空间
		HPDataType* tmp = (HPDataType*)realloc(php->a, sizeof(HPDataType) * newcapacity);
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
		php->capacity = newcapacity;
		php->a = tmp;
	}
	//插入数据
	php->a[php->size] = x;
	php->size++;
	//向上调整
	AdjustUp(php->a, php->size - 1);
}

//向下调整
void AdjustDown(HPDataType* 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[child], &a[parent]);
			//更新父亲和孩子节点
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

//删除
void HeapPop(Heap* php)
{
	assert(php);
	//判断堆是否为空
	assert(!HeapEmpty(php));
	//交换堆顶的数据和最后的数据
	Swap(&php->a[0], &php->a[php->size - 1]);
	//删除最后的数据
	php->size--;
	//向下调整
	AdjustDown(php->a, php->size, 0);
}

//判空
bool HeapEmpty(Heap* php)
{
	assert(php);
	return php->size == 0;
}

//获取堆顶元素
HPDataType HeapTop(Heap* php)
{
	assert(php);
	//判断堆是否为空
	assert(!HeapEmpty(php));
	return php->a[0];
}

//堆排序
void HeapSort(int* a, int n)
{
	//建堆
	Heap 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);
}

int main()
{
	int a[] = { 5,6,8,9,7,4,5,2,3,6 };
	int sz = sizeof(a) / sizeof(int);
	HeapSort(a, sz);
	return 0;
}

我们在这里建的是小堆，所以是排成了升序的状态，建大堆只要将向上调整和向下调整的小于号换成大于号即可。

这种算法有点弊端：

1. 必须先要有一个堆，太麻烦。

2. 将数组的数据拷贝至堆，又将堆的数据拷贝至数组，空间复杂度上面代价有点大。

但是这种算法的时间复杂度也是不错的，在前面我们讲堆的时候提到过向上调整算法和向下调整算法，这两种算法的时间复杂度都是O(logN)，那么在这个堆排序的算法中的时间复杂度加上遍历数组的时间复杂度合起来为O(N*logN)。