二叉树（三）——堆排序优化、TOP K问题

一、堆排序优化       

上一讲采用先独立建小堆，再把数组元素全部放入小堆中，最后从小堆弹出所有元素实现堆排序，固然达到了O（NlogN）的时间复杂度，但空间复杂度为O（N），值得优化。

优化堆排序的思路如下（以升序为例）：

//针对大堆的向下调整
void AdjustDown(HPDataType* a,size_t size,size_t root)
{
	size_t parent = root;
	size_t child = parent * 2 + 1;
	while (child < size)
	{
		//第一步：选出左右孩子中较大的一个
		if (child + 1 < size && a[child + 1] > a[child])
		{
			child++;
		}
		//如果孩子大于父亲则交换，并继续往下调整
		if (a[child] > a[parent])
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

我们回顾大堆中元素的删除（堆中元素数量为N，数组实现）：

第一次删除，最大元素位于根结点（a[0]），先与a[N-1]交换，再对a[0]向下调整。

第二次删除，第二大元素位于根结点（a[0]），先与a[N-2]交换，再对a[0]向下调整。

······

也就是说，大堆中第k次删除，能保证数组中第k大数被放在合适的位置（升序排序）。

该方法也利用了缩小规模的思想。

具体代码：

void HeapSort(HPDataType* a, size_t n)
{
	//升序排序，建小堆之后不方便操作，不如直接冒泡
	//建堆有两种方法
	//一种是用向上调整插入数据的思想建堆
	//第一步：在原有数组基础之上建堆
	int i = 0;
	/*for (i = 1; i < n; i++)
	{
		AdjustUp(a, i);
	}*/
	//注意：直接向下调整不能建堆，向下调整的要求：左右子树都是小堆/都是大堆
	//用向下调整建堆，应该从倒数第一个internal vertex开始,倒着向下调整
	//倒数第一格internal vertice，即为最后一个leaf的父节点
	for (i = (n - 1) / 2; i >= 0; i--)
	{
		AdjustDown(a, n,i);
	}
	//①堆排序（升序）利用了减少规模的思想：
	//第一次选出最大数，然后规模缩减到n-1......
	//②堆排序的本质是选择排序
	//利用堆的结构第i次选出第i大数
	size_t end = n - 1;
	while (end>0  )
	{
		Swap(&a[0], &a[end]);
		AdjustDown(a, end, 0);
		end--;
	}
}

int main()
{
	TestHeap();
	HPDataType a[] = { 4,2,7,8,5,1,0,6 };
	HeapSort(a, sizeof(a) / sizeof(HPDataType));
	for (size_t i = 0; i <= 7; i++)
		printf("%d ", a[i]);
	return 0;
}

完整代码文件如下：

Heap.h

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

typedef int HPDataType;
typedef struct Heap {
	HPDataType* a;//动态数组
	size_t size;//数据量
	size_t capacity;//容量
}HP;
void Swap(HPDataType* pa, HPDataType* pb);
void HeapInit(HP* php);
void HeapDesTroy(HP* php);
void HeapPush(HP* php, HPDataType x);
void HeapPop(HP* php);
void HeapPrint(HP* php);
HPDataType HeapTop(HP* php);
size_t HeapSize(HP* php);
bool HeapEmpty(HP* php);
void AdjustUp(HPDataType* a, size_t child);
void AdjustDown(HPDataType* a, size_t size, size_t root);

Heap.c

#include"Heap.h"
void HeapInit(HP* php)
{
	assert(php);
	php->a = NULL;
	php->size = php->capacity = 0;
}
void HeapDesTroy(HP* php)
{
	assert(php);
	free(php->a);
	php->a = NULL;//这一步不要忽略
	php->size = php->capacity = 0;
}

void Swap(HPDataType* pa, HPDataType* pb)
{
	HPDataType tmp = *pa;
	*pa = *pb;
	*pb = tmp;
}

//算法逻辑思想是二叉树，物理上操作的是数组中数据
//针对小堆的向上调整
void AdjustUp(HPDataType* a,size_t child)
{
	//父子关系计算公式（对于leftchild和rightchild均成立）
	size_t parent = (child - 1) / 2;
	//可能会持续上调
	//此处为小堆，若需要大堆，则只用调整if中的符号就行
	while (child>0)
	{
		if (a[child] < a[parent])
		{
			Swap(&a[child], &a[parent]);
			//更新关系
			child = parent;
			parent = (child - 1) / 2;
			//注意child=0时，parent=0,会陷入死循环。
			//无论用不用size_t，parent始终不会小于0
			//-1/2==0
		}
		//还应该考虑中间就停止的情况
		else
		{
			break;
		}
	}
}


//插入新数据后，要保持大根堆、小根堆的性质
void HeapPush(HP* php, HPDataType x)
{
	assert(php);
	//空间不够，先扩容
	if (php->capacity == php->size)
	{
		size_t newCapacity = php->capacity * 2 + 1;
		HPDataType* tmp = realloc(php->a, sizeof(HPDataType) * newCapacity);
		if (tmp == NULL)
		{
			printf("realloc failed.\n");
			exit(-1);
		}
		php->a = tmp;
		php->capacity = newCapacity;
	}
	//堆中插入数据——向上调整算法
	//第一步：先把新数据放在物理结构（顺序表/数组）的尾部
	php->a[php->size] = x;
	++php->size;
	//第二步：向上调整
	AdjustUp(php->a, php->size - 1);
}
void HeapPrint(HP* php)
{
	assert(php);
	for (size_t i = 0; i < php->size; i++)
	{
		printf("%d ",php->a[i]);
	}
	printf("\n");
}

//针对大堆的向下调整
void AdjustDown(HPDataType* a,size_t size,size_t root)
{
	size_t parent = root;
	size_t child = parent * 2 + 1;
	while (child < size)
	{
		//第一步：选出左右孩子中较大的一个
		if (child + 1 < size && a[child + 1] > a[child])
		{
			child++;
		}
		//如果孩子大于父亲则交换，并继续往下调整
		if (a[child] > a[parent])
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}
//删除堆顶数据（小堆-删除堆顶最小数据/大堆-删除堆顶的最大数据）
//要保持小堆/大堆的性质
//若直接前移剩余数据，则有问题：①破坏结构②时间复杂度为O（N）,不方便
//更优秀的方案：第一个数据先和最后一个数据进行对调->不必抹掉数据，直接size--即可->向下调整
void HeapPop(HP* php)
{
	assert(php);
	assert(php->size > 0);
	//第一步：根与最后一个数据进行交换
	Swap(&php->a[0], &php->a[php->size-1]);
	//第二步：删除数据
	--php->size;
	//第三步：向下调整
	//时间复杂度：O(logN)
	AdjustDown(php->a,php->size,0);
}
HPDataType HeapTop(HP* php)
{
	assert(php);
	assert(php->size > 0);
	return php->a[0];
}
size_t HeapSize(HP* php)
{
	assert(php);
	return php->size;
}
bool HeapEmpty(HP* php)
{
	assert(php);
	return php->size == 0;
}

main.c

#include"Heap.h"

void TestHeap()
{
	HP hp;
	HeapInit(&hp);
	HeapPush(&hp, 1);
	HeapPush(&hp, 5);
	HeapPush(&hp, 0);
	HeapPush(&hp, 8);
	HeapPush(&hp, 3);
	HeapPush(&hp, 9);
	HeapPrint(&hp);
	HeapPop(&hp);
	HeapPrint(&hp);
	HeapDesTroy(&hp);
}

//堆排序的步骤比较简单，即：
//将数组中的无序元素全部放到一个新建的堆中，再依次pop出，即得有序的元素列
//堆排序——升序
//void HeapSort(HPDataType* a, int size)
//{
//	//第一步：建立一个堆（小堆）
//	HP hp;
//	HeapInit(&hp);
//	//第二步：将数组中的无序数据都放到堆中
//	//第三步：由于小堆可以依次弹出从小到大的数据，故依次放入数组即可
//	for (int i = 0; i < size; ++i)
//	{
//		HeapPush(&hp, a[i]);
//	}
//	size_t j = 0;
//	while (!HeapEmpty(&hp))
//	{
//		a[j] = HeapTop(&hp);
//		j++;
//		HeapPop(&hp);
//	}
//	HeapDesTroy(&hp);
//}
//方法二：空间复杂度为O(1)
//升序
void HeapSort(HPDataType* a, size_t n)
{
	//升序排序，建小堆之后不方便操作，不如直接冒泡
	//建堆有两种方法
	//一种是用向上调整插入数据的思想建堆
	//第一步：在原有数组基础之上建堆
	int i = 0;
	/*for (i = 1; i < n; i++)
	{
		AdjustUp(a, i);
	}*/
	//注意：直接向下调整不能建堆，向下调整的要求：左右子树都是小堆/都是大堆
	//用向下调整建堆，应该从倒数第一个internal vertex开始,倒着向下调整
	//倒数第一格internal vertice，即为最后一个leaf的父节点
	for (i = (n - 1) / 2; i >= 0; i--)
	{
		AdjustDown(a, n,i);
	}
	//①堆排序（升序）利用了减少规模的思想：
	//第一次选出最大数，然后规模缩减到n-1......
	//②堆排序的本质是选择排序
	//利用堆的结构第i次选出第i大数
	size_t end = n - 1;
	while (end>0  )
	{
		Swap(&a[0], &a[end]);
		AdjustDown(a, end, 0);
		end--;
	}
}

int main()
{/*
	TestHeap();*/
	HPDataType a[] = { 4,2,7,8,5,1,0,6 };
	HeapSort(a, sizeof(a) / sizeof(HPDataType));
	for (size_t i = 0; i <= 7; i++)
		printf("%d ", a[i]);
	return 0;
}

二、Top K问题

问题描述：求数据中前K个最大或者最小的元素。一般情况下，数据量都比较庞大。

基本思路：利用堆解决。

操作目的：空间复杂度是O（1），时间复杂度是O（N），尽量减少额外开辟的空间。

第一步：利用数据集合中的前K个元素建堆

求前K个最大的元素，建立小堆

求前K个最小的元素，建立大堆

第二步：用剩余的N-K个元素与堆顶进行比较

求前K个最大的元素：建立小堆之后，如果某个剩余元素比堆顶大，则说明这个剩余元素应该替换堆顶。

求前K个最小的元素，建立大堆之后，如果某个剩余元素比堆顶小，则说明这个剩余元素应该替换堆顶。

每一次替换，都是剔除堆中最不合理的元素。比如求前K个最大的元素，替换一次，是把小堆中最小的元素换掉，用一个比它更可能成为前K大的元素替换它，使堆中元素愈发接近最终结果。

代码实现：

void PrintTopK(int* a, int n, int k)
{
	//第一步:建立小堆
	int* kminHeap = (int*)malloc(sizeof(int) * k);
	assert(kminHeap);
	//先把元素放进去
	for (int i = 0; i < k; i++)
	{
		kminHeap[i] = a[i];
	}
	//再从倒数第一个非叶子结点开始，进行向下调整，使之成为小堆
	for (int j = (k - 1 - 1) / 2; j >= 0; j--)
	{
		AdjustDown(kminHeap, k, j);
	}
	//第二步：元素替换
	for (int i = k; i < n; i++)
	{
		if (a[i] > kminHeap[0])
		{
			Swap(&a[i], &kminHeap[0]);
			AdjustDown(kminHeap, k, 0);
		}
	}
	for (int i = 0; i < k; i++)
	{
		printf("%d ", kminHeap[i]);
	}
}

void TestTopK()
{
	int i;
	int* a = (int*)malloc(sizeof(int) * 5000);
	for (i = 0; i < 5000; i++)
	{
		a[i] = rand() % 1000000;
	}
	a[1] = 1000000 + 1;
	a[1237] = 1000000 + 3;
	a[1023] = 1000000 + 2;
	a[4900] = 1000000 + 4;
	PrintTopK(a, 5000, 4);
}
int main()
{/*
	TestHeap();*/
	/*HPDataType a[] = { 4,2,7,8,5,1,0,6 };
	HeapSort(a, sizeof(a) / sizeof(HPDataType));
	for (size_t i = 0; i <= 7; i++)
		printf("%d ", a[i]);
	return 0;*/
	TestTopK();
}