5.2二叉树——堆

本篇博客梳理一个重要的数据结构——堆
注意：若无特殊说明，默认是小堆进行分析

一、堆的概念与分类

1．堆是完全二叉树

2．大堆：父亲≥孩子；小堆：父亲≤孩子

注意：兄弟之间无法确定大小关系

typedef int HPDataType;
typedef struct Heap//堆
{
	HPDataType* a;
	int size;//有效数据个数
	int capacity;//空间容量大小
}Heap;

二、堆的向上/向下调整算法（以小堆为例，大堆反之）

1．向上调整算法

目标节点与所有祖先比较，若父亲≥孩子，则交换

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;
		}
	}
}

2．向下调整算法

目标节点与左右子结点中较小者比较，若父亲≥孩子，则交换
注意：前提是目标节点的左右子树都要满足堆

void Swap(HPDataType* x, HPDataType* y)
{
	HPDataType tmp = *x;
	*x = *y;
	*y = tmp;
}
void adjustDown(HPDataType* a, int size,int parent)
{
	int child = 2 * parent + 1;
	while (child < size)
	{
		//找出小的那个孩子
		if (child + 1 < size && a[child] > a[child + 1])
		{
			child++;
		}
		//此时child下标对应的是较小的那个孩子
		if (a[child] < a[parent])
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = 2 * parent + 1;
		}
		else
		{
			break;
		}
	}
}

三、堆的实现

1．创建堆（向上调整or向下调整）

先说结论：向下调整建堆时间复杂度更优

（1）向上调整建堆

从第二个结点开始往后依次遍历，有需要就调整
特点：节点数量多的层调整次数也多，节点数量少的层调整次数少
时间复杂度：o(N·logN)
时间复杂度证明：假设树的高度为h，h从1开始

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;
		}
	}
}

（2）向下调整建堆（更优）

从最后一个结点的父结点开始，往前依次遍历，有需要就调整
思想：先把小的树调成堆，再逐层往上，不断扩大“堆的势力范围”
特点：节点数量多的层调整次数少，节点数量少的层调整次数多
时间复杂度：o(N)
时间复杂度证明：假设树的高度为h，h从1开始

void adjustDown(HPDataType* a, int size,int parent)
{
	int child = 2 * parent + 1;
	while (child < size)
	{
		//找出小的那个孩子
		if (child + 1 < size && a[child] > a[child + 1])
		{
			child++;
		}
		//此时child下标对应的是较小的那个孩子
		if (a[child] < a[parent])
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = 2 * parent + 1;
		}
		else
		{
			break;
		}
	}
}

2．堆的插入

先尾插，再进行向上调整算法

void HeapPush(Heap* hp, HPDataType x)//堆的插入(向上调整算法)
{
	assert(hp);
	if (hp->size == hp->capacity)//数组已满，需要扩容
	{
		int newcapacity = (hp->capacity == 0) ? 4 : 2 * (hp->capacity);
		HPDataType* arr = (HPDataType*)realloc(hp->a,sizeof(HPDataType) * newcapacity);
		if (arr == NULL)
		{
			perror("malloc failed");
			return;
		}
		hp->a = arr;
		hp->capacity = newcapacity;
	}
	hp->a[hp->size] = x;
	hp->size++;
	adjustUp(hp->a,hp->size-1);
}

3．堆的删除：删除堆顶的数据

将堆顶的数据和最后一个数据交换，再删除数组最后一个数据，最后进行向下调整算法
（1）交换再删除的目的：保证其余父子关系不乱。如果直接删除堆顶数据，再将其余元素往前挪动一个位置，会导致父子关系乱掉
（2）如果是小堆，即可保证每次删掉的数据都是最小的数据，并且每删一次，次小的数据会到达堆顶（保证了删除的有序性），从小到大删（大堆反之）
（3）时间复杂度分析
假设树节点个数为N，则树高为h=log(N+1)，由于一个节点换到堆顶最多往下调（h-1）次，因此时间复杂度为o(logN)

void HeapPop(Heap* hp)//堆的删除
{
	assert(hp);
	assert(hp->size > 0);
	Swap(&hp->a[0], &hp->a[hp->size - 1]);//交换堆顶和最后一个数据
	hp->size--;//删除最后一个数据
	adjustDown(hp->a, hp->size , 0);//向下调整

}

四、堆排序与TopK问题

1．堆排序

（1）第一步：建堆，如果要排成降序则建小堆，排成升序则建大堆
（2）第二步：利用堆删除思想进行排序
在这里读者可能会有疑问，为什么排成降序要建小堆，建大堆的话最大的不是直接在堆顶了么？原因分析放在后面
具体的操作步骤如下
①交换最后一个元素和堆顶元素
②堆顶元素向下调整
③换到最后的数据不看做堆内数据（“伪删除”）
例如：想把9 7 8 5 2 4 6 1排成降序，则需要先建成小堆

void Swap(int* x, int* y)
{
	int tmp = *x;
	*x = *y;
	*y = tmp;
}
//向下调整算法
void adjustDown(int* arr, int size, int parent)
{
	int child = 2 * parent + 1;
	while (child < size)
	{
		//找出较小的孩子
		if (child + 1 < size && arr[child] > arr[child + 1])
		{
			child++;
		}
		//开始调整，交换元素
		if (arr[parent] > arr[child])
		{
			Swap(&arr[parent], &arr[child]);
			parent = child;
			child = 2 * parent + 1;
		}
		else
		{
			break;
		}
	}

}
void HeapSort(int* a, int size, int parent)//堆排序
{
	int end = size - 1;
	while (end >= 0)
	{
		Swap(&a[0], &a[end]);//交换堆顶元素和最后一个数据
		adjustDown(a, end, 0);//堆顶元素进行向下调整算法
		end--;//最后一个数据不看做堆内元素，“伪删除”
	}
}
int main()
{
	int arr[] = { 9,7,8,5,2,4,6,1 };
	int size = sizeof(arr) / sizeof(arr[0]);
	//建堆，用向下调整算法，逐个子树调，最后到整棵树
	for (int i = ((size - 1) - 1) / 2; i >= 0; i--)//((size - 1) - 1)  / 2是最后一个结点的父结点
	{
		adjustDown(arr, size, i);//向下调整建堆
	}
	//堆排序
	HeapSort(arr, size, 0);
	for (int i = 0; i < size; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

现在来分析一下，为什么排成降序不建大堆？
以9 7 8 5 2 4 6 1为例，如果建立大堆，那么建堆之后9在堆顶不能动了，剩下的元素要排序只能重新建堆，导致父子关系全乱，比较麻烦，所以排成降序推荐建小堆

2．TopK问题

求数据集合中前K个最大的或者最小的元素，一般情况下数据量比较大
例：在N个数中找出最大的前k个

（1）方法一

①建一个N个数的大堆（向下调整算法建堆），时间复杂度o(N)
②pop（删除）操作k次，记录下每次删除的数据，时间复杂度o(k*logN)，即o(logN)
合计的时间复杂度：o(N)
缺陷：当N很大时内存存不下

（2）方法二（空间上提升很多）

①用数据集合中前k个元素来建堆——建小堆
②用剩余的N-K个元素依次与堆顶元素比较，如果比堆顶的数据大，就替换堆顶，然后向下调整

• 优势分析：大的数据来了则必进堆（比如k=10，则排名第1到第9的数据都不会挡在堆顶）
• 时间复杂度分析
  建堆：o(k)，也就是o(1)
  向下调整过程：最坏就是每次进堆都要调整到最后一层，o((N-K)*log(k+1))，【结点数为k,则树高log(k+1)】
  合计时间复杂度：o(N)

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
void CreateNDate()
{
	// 造数据
	int n = 20;
	srand(time(0));
	const char* file = "data.txt";
	FILE* fin = fopen(file, "w");
	if (fin == NULL)
	{
		perror("fopen error");
		return;
	}

	for (size_t i = 0; i < n; ++i)
	{
		int x = rand() % 20;
		fprintf(fin, "%d\n", x);
	}

	fclose(fin);
}

void Swap(int* x, int* y)
{
	int tmp = *x;
	*x = *y;
	*y = tmp;
}

//向下调整算法
void adjustDown(int* arr, int size, int parent)
{
	int child = 2 * parent + 1;
	while (child < size)
	{
		//找出较小的孩子
		if (child + 1 < size && arr[child] > arr[child + 1])
		{
			child++;
		}
		//开始调整，交换元素
		if (arr[parent] > arr[child])
		{
			Swap(&arr[parent], &arr[child]);
			parent = child;
			child = 2 * parent + 1;
		}
		else
		{
			break;
		}
	}

}

void PrintTopK(int k,int n)
{
	FILE* pf = fopen("data.txt", "r");
	if (pf == NULL)
	{
		perror("fopen error");
		return;
	}

	int* arr = (int*)malloc(sizeof(int) * k);
	for (int i = 0; i < k; i++)
	{
		fscanf(pf, "%d", &arr[i]);
	}

	//建堆，用向下调整算法，逐个子树调，最后到整棵树
	for (int i = ((k - 1) - 1) / 2; i >= 0; i--)//((size - 1) - 1)  / 2是最后一个结点的父结点
	{
		adjustDown(arr, k, i);
	}
	int ret = 0;
	while (fscanf(pf, "%d", &ret) > 0)
	{
		if (arr[0] <= ret)
		{
			arr[0] = ret;
			adjustDown(arr, k, 0);
		}
	}
	for (int i = 0; i < k; i++)
	{
		printf("%d ", arr[i]);
	}
}

int main()
{
	CreateNDate();
	PrintTopK(3,20);//找出前十个最大的数
	return 0;
}