堆排序——C语言实现

  在实现堆排序之前，我们先讲解一些必备的知识点。

一、什么是堆？

堆的逻辑结构是完全二叉树； 堆的物理结构是一个数组。

⚽二、堆的分类：

大堆：所有的父亲大于等于孩子；
小堆：所有的父亲小于等于孩子。

三、父亲和孩子的下标关系：

leftchild=parent×2+1;
rightchild=parent×2+2;
parent=(child-1)/2。

四、堆能干什么？

大堆能保证堆顶的数最大； 小堆能保证堆顶的数最小； 堆排序也正是利用这一特性进行排序的。

⚾五、如何进行堆排序？

✈️1、建堆：
  根据第四点我们知道，堆排序是利用大堆或者小堆堆顶数据最大或最小的特性来进行排序的，所以，我们排序的对象必须是大堆或者小堆，但给定的数据肯定不能是大堆或者小堆，所以这里我们必须先建堆。
2、向下调整算法（建小堆）：
  建堆之前我们必须知道向下调整算法，也是堆排的核心。

其基本思想是：从根结点开始，选出左右孩子中的较小值，将其和父亲比较，如果小于（建大堆的话就大于父亲交换）父亲就交换，然后继续向下调，直到调到叶子结点终止。

注意：向下调整算法有一个前提，左右子树必须是大堆或者小堆才能进行调整。

向下调整算法的代码为：

注释：arr为数组的地址，n为数组元素个数，root为根结点的下标

//交换代码
void Swap(int* p1, int* p2)
{
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

/向下调整算法
void AdjustDown(int* arr, int n, int root)
{
	int parent = root;
	int child = parent * 2 + 1;//默认先对左孩子进行操作
	while (child<n)
	{
		//选出左右孩子较小的那一个
		//child+1
		if (child+1<n && arr[child + 1] > arr[child]) //建小堆用小于，建大堆用大于
		{
			child += 1;
		}

		if (arr[child] > arr[parent]) //建小堆用小于，建大堆用大于
		{
			Swap(&arr[child], &arr[parent]);//交换父子的值
			parent = child;//父亲到孩子的位置，继续向下调整
			child = parent * 2 + 1;//默认又从左孩子开始
		}
		else
		{
			break;
		}
	}
}

️3、建堆思路和代码：
  由于向下调整算法的使用前提是左右子树必须是大堆或者小堆，那么对于待排序序列该怎么保证左右子树都是大堆或者小堆呢？

解决方法：我们倒着从最后一个子树开始调整，那么必定能保证满足这个前提。继续分析，叶子结点是不需要调整的，所以我们从倒数第一个非叶子结点开始调整。

【我们如何找到这个非叶子结点？】

✌我们发现，这个结点是最后一个结点的父亲，最后一个结点的下标为n-1，套用公式：parent=(child-1)/2，则该结点下标为（n-1-1）/2。

建堆的代码为：

//建堆,排升序建大堆，排降序建小堆
	for (int i = (n - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(arr, n, i);
	}

这里我们解释一下，为什么排升序建大堆，排降序建小堆。

因为我们接下来要用到的排序基本思路为：出堆顶，然后继续利用向下调整算法。如果我们排升序建小堆，那么我们的堆顶则不动，在剩下的数再去选数，但是剩下的数结构全乱了，需要重新进行建堆，不是不，但无效率可言。

由此可见，在选出10后，接下来的树既不是大堆也不是小堆，又要重新建堆，效率低。

所以我们建大堆：第一个和最后一个元素交换，把它不看做堆里面的数，前n-1个数继续向下调整，选出次大的数，和倒数第二个位置的数交换。

4、堆排序完整代码如下，可直接复制运行：

#include

void Print(int* arr, int n)
{
	for (int i = 0; i < n; i++)
	{
		printf("%d ", arr[i]);
	}
}

void Swap(int* p1, int* p2)
{
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

//向下调整算法
void AdjustDown(int* arr, int n, int root)
{
	int parent = root;
	int child = parent * 2 + 1;//默认先对左孩子进行操作
	while (child<n)
	{
		//选出左右孩子较小的那一个
		//防止没有右孩子，数组越界
		if (child+1<n && arr[child + 1] > arr[child]) //建小堆用小于，建大堆用大于
		{
			child += 1;
		}

		if (arr[child] > arr[parent]) //建小堆用小于，建大堆用大于
		{
			Swap(&arr[child], &arr[parent]);//交换父子的值
			parent = child;//父亲到孩子的位置，继续向下调整
			child = parent * 2 + 1;//默认又从左孩子开始
		}
		else
		{
			break;
		}
	}
}

void HeapSort(int* arr, int n)
{
	//建堆,排升序建大堆，排降序建小堆
	for (int i = (n - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(arr, n, i);
	}

	//排升序
	int end = n - 1;//end为最后一个数的下标
	while (end > 0)//剩余超过一个数就交换
	{
		Swap(&arr[0], &arr[end]);
		AdjustDown(arr, end, 0);
		end--;
	}
}

void test()
{
	int arr[] = { 10,9,8,7,6,5,3,5,4,2,0,1 };
	int n = sizeof(arr) / sizeof(arr[0]);
	HeapSort(arr, n);
	Print(arr, n);
}

int main()
{
	test();
	return 0;
}