数据结构系列-堆排序

🌈个人主页：羽晨同学 

💫个人格言:“成为自己未来的主人~”  

 今天我们开始讲解一下堆排序和T-TOK问题，这个也是堆排序相对于qsort排序和冒泡排序来说最大的竞争力，首先我们回顾一下之前我们学过的qsort排序和冒泡排序。

回顾

首先是qsort排序

qsort排序是包含在#include这个库文件当中，由于qsort排序属于快速排序，所以它的时间复杂度是NlogN，空间复杂度N

然后是冒泡排序

冒泡排序的时间复杂度是N^2，空间复杂度是O（1）

在我们已知的排序算法当中，我们可以看到的就是，冒泡排序所花的时间复杂度太高，只是涉及单纯的遍历，所以，这个也是堆排序的优点，在堆排序当中，我们会用到两个算法，一个是向上调整算法，一个是向下调整算法，这两个算法的时间复杂度是不同的，具体的我们稍后再说。

若是想实现堆排序，我们需要手凹一个堆，堆的搭建我们再前面讲过，它的底层逻辑就是一个数组

首先，我们按照惯例，先对Int进行另外命名，

typedef int HPDataType;

接下来，我们对堆的基本信息进行完善，里面有两个指标，一个是size，检测有效空间，一个是capacity，检测开发空间

typedef struct Heap
{
	HPDataType* a;
	int size;
	int capacity;
}HP;

然后我们在头文件当中，先做几个声明，声明一下我们要实现的基本功能

void HPInit(HP* php);
void HPInitArray(HP* php, HPDataType* a, int n);
 
void HPDestroy(HP* php);
// 插入后保持数据是堆
void HPPush(HP* php, HPDataType x);
HPDataType HPTop(HP* php);
 
// 删除堆顶的数据
void HPPop(HP* php);
 
bool HPEmpty(HP* php);
 
void AdjustUp(HPDataType* a, int child);
void AdjustDown(HPDataType* a, int n, int parent);
void Swap(HPDataType* px, HPDataType* py);

然后我们就开始在C文件当中实现这些功能

首先，按照常规，我们先对堆进行初始化。

void HPInit(HP* php)
{
	assert(php);
	php->a = NULL;
	php->size = 0;
	php->capacity = 0;
}

检测传入的php是否为空，将php中的a置为空，将有效长度和有效空间均赋值为0

接下的的操作中，我们对堆的搭建方式有两种，一种是之前的malloc开辟空间，但是这样造成的时空间浪费比较大，另外一种我们先开辟空间，然后进行copy，给到另一块空间，这样子会最大程度的避免空间的浪费

void HPInitArray(HP* php, HPDataType* a, int n)
{
	assert(php);
	
	php->a = (HPDataType*)malloc(sizeof(HPDataType) * n);
	if (php->a == NULL)
	{
		perror("malloc fail");
		return;
	}
	memcpy(php->a, a, sizeof(HPDataType) * n);
	php->capacity = php->size = n;
 
	// 向上调整，建堆 O(N*logN)
	//for (int i = 1; i < php->size; i++)
	//{
	//	AdjustUp(php->a, i);
	//}
 
	// 向下调整，建堆 O(N)
	for (int i = (php->size-1 - 1)/2; i >= 0; i--)
	{
		AdjustDown(php->a, php->size, i);
	}
}

 在这里面最关键的就是将a里面的内容放到了php->a里面，由于堆的逻辑结构是二叉树，所以我们对它进行调整，调整的方式有两种，一种是向上调整，它的时间复杂度是NlogN，另外一种是向下调整算法，它的时间复杂度是N，

void HPDestroy(HP* php)
{
	assert(php);
	free(php->a);
	php->a = NULL;
	php->capacity = 0;
	php->size = 0;
}
 
void Swap(HPDataType* px, HPDataType* py)
{
	HPDataType tmp = *px;
	*px = *py;
	*py = tmp;
}
 
void AdjustUp(HPDataType* a, int child)
{
	int parent = (child - 1) / 2;
	//while (parent >= 0)
	while(child > 0)
	{
		if (a[child] > a[parent])
		{
			Swap(&a[child], &a[parent]);
			child = parent;
			parent = (parent - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

这些向上调整算法，交换，删除，均为之前强掉的内容 ，我们在这里就不详细展开

和前面的copy的堆的搭建构成区别的是，我们之前使用的那种HPPush的做法，大家可以想象这种做法的时间复杂度是什么

// 时间复杂度：
void HPPush(HP* php, HPDataType x)
{
	assert(php);
 
	if (php->size == php->capacity)
	{
		size_t newCapacity = php->capacity == 0 ? 4 : php->capacity * 2;
		HPDataType* tmp = realloc(php->a, sizeof(HPDataType) * newCapacity);
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
		php->a = tmp;
		php->capacity = newCapacity;
	}
 
	php->a[php->size] = x;
	php->size++;
 
	AdjustUp(php->a, php->size-1);
}

这个的时间复杂度是o(N)

HPDataType HPTop(HP* php)
{
	assert(php);
 
	return php->a[0];
}
 
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;
		}
	}
}

这个就是我们要实现的另外几个功能，这个在之前的文章中也有讲到，所以我们就快速过了

接下来讲的是Pop操作

// 时间复杂度：logN
void HPPop(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);
}

在这个操作当中，我们的实现逻辑是先头尾交换，删除尾，然后进行调整，此时的时间复杂度是logN

这个就是我们实现的大致逻辑，然后再下一章当中，我们将会给大家讲解T-TOK问题