数据结构——堆与堆排序

完全二叉树：假设其深度为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)

实现思路

主要分为以下两个步骤：

1. 通过向下调整或向上调整来进行建堆（至于要建大堆还是小堆就得看你想要升序还是降序了）
2. 建立大堆后（小堆），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。