【数据结构】二叉树，堆

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

一、堆是什么？

堆就是将一组数据所有元素按完全二叉树的顺序存储方式存储在一个一维数组中，并满足树中每一个父亲节点都要大于其子节点称为大堆(树中每一个父亲节点都要大于其子节点称为小堆)。

1.性质

 对于大堆(大根堆)来说,堆的顶部也就是数组首元素一定是最大的元素
 对于小堆(小根堆)来说,堆的顶部也就是数组首元素一定是最小的元素
 堆是一棵完全二叉树,因为堆本身就是二叉树的一种顺序存储结构的实现模式

注意的是这里的堆和操作系统虚拟进程地址空间中的堆是两回事，一个是数据结构，一个是操作系统中管理内存的一块区域分段

2.图解

 ![在这里插入图片描述](https://img-blog.csdnimg.cn/02772e3a83b34253b32139cbf97db19e.png#pic_center)

3.节点关系

LeftChild = Parent * 2 + 1; //左孩子的节点下标
RightChild = Parent * 2 + 2; //右孩子的节点下标
Parent = (Child - 1) / 2;  

二、堆的实现

1.向上调整算法

向上调整算法主要用于堆的插入和堆排序中

堆的插入
就是在数组的末尾进行数字的插入,并且在插入数据之后,我们仍要保证现有的结构仍然是一个堆，由于插入后结构发生变化，需要重新调整堆。

typedef struct HeapNode
{
	HeapDataType* a;
	int size;
	int capacity;
}HP;
void Swap(HeapDataType* p1, HeapDataType* p2)
{
	HeapDataType tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

void AdjustUp(HeapDataType* a, int child)  //child,parent是下标
{
	int parent = (child - 1) / 2;
	while (child > 0)
	{
		//小堆:判断子节点和父亲结点的大小
		if (a[child] < a[parent])
		//大堆：if (a[child] > a[parent])
		{
			Swap(&a[child], &a[parent]);//交换孩子和父亲
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

2.向下调整算法

代码如下：

void AdjustDown(int* a,int n,int parents)
{
	int child = 2 * parents + 1;
	while (child < n)//n为数组尺寸，child为左孩子下标
	                 //如果没有右孩子的话,这次循环将会终止,调整就会进行不彻底
	{
		if (child+1<n && a[child] > a[child + 1])//小堆
		{
			child++;
		}
		if (a[child] < a[parents])//比较，把小的换上来（小堆）
		{
			int temp = a[child];
			a[child] = a[parents];
			a[parents] = temp;
			parents = child;
			child = 2 * parents + 1;//交换未知
		}
		else
		{
			break;
		}
	}
}

三.堆的接口实现

1.堆的创建

堆在物理结构上是一个数组，故创建一个顺序表结构体

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

初始化堆

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

销毁堆

void HeapDestroy(HP* hp)
{
	assert(hp);

	free(hp->a);
	hp->a = NULL;
	hp->size = hp->capacity = 0;
}

堆插入元素

尾部插入元素，再使用向上调整重新形成堆

void HeapPush(HP* hp, HPDataType x)
{
	assert(hp);

	// 扩容
	if (hp->size == hp->capacity)
	{
		int new = hp->capacity == 0 ? 4 : hp->capacity * 2;
		HPDataType*tmp=(HPDataType*)realloc(hp->a, sizeof(HPDataType) * new);
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(-1);
		}

		hp->a = tmp;
		hp->capacity = new;
	}

	hp->a[hp->size] = x;
	hp->size++;

	AdjustUp(hp->a, hp->size - 1);//插入之后向上调整堆
}

堆删除元素

void HeapPop(HP* php)
{
	assert(php);
	assert(php->size > 0);

	Swap(&php->a[0], &php->a[php->size - 1]);//首元素换到尾部来,然后再size--删除最后一个元素
	--php->size;

	AdjustDown(php->a, php->size, 0);//再用AdjustDown函数再来调整堆
}

打印元素

void HeapPrint(HP* php)
{
	assert(php);

	for (size_t i = 0; i < php->size; i++)
	{
		printf("%d ", php->a[i]);
	}
	printf("\n");
}

判断为空

bool HeapEmpty(HP* php)
{
	assert(php);
	return php->size == 0;
}

取首元素

HPDataType HeapTop(HP* php)
{
	assert(php);
	assert(php->size > 0);
	return php->a[0];
}

实现堆

int main()
{
	HP hp;
	HeapInit(&hp);
	int a[] = { 20, 11, 28, 31, 111, 52, 34, 16, 7, 9 };
	for (int i = 0; i < sizeof(a) / sizeof(int); i++)
	{
		HeapPush(&hp, a[i]);//插入
	}
	HeapPop(&hp);//把堆的首元素7删除删除
	HeapPrint(&hp);
	printf("堆顶元素：%d\n", HeapTop(&hp));
	HeapDestroy(&hp);
	return 0;
}

四.堆排序

堆排序分为两个步骤，创建堆和调整堆

1.创建堆

创建堆的方式有两种①向上调整建堆 ②向下调整建堆

①向上调整建堆

通过AdjustUp函数和一个for循环就可以完成上面步骤，AdjustUp()的时间复杂度为O(logn),然后循环了n此每次建堆,所以两者相乘,时间复杂度也就是 n*logn

//以前n个数建小堆
for (int i = 0; i < n; ++i)
{
	AdjustUp(a, i);  //a为数组的指针
}

②向下调整建堆

这种建堆的关键就是从倒数第一个非叶子节点开始调(也就是树中最后一个父节点),然后逐渐+1,就可以调整从最后一个父节点开始的每一棵树.
不难发现这样也符合向下调整的前提,即左右子树都是堆
那么我们如何找到最后一个节点的父亲?
就需要用到公式:Parent = (Child - 1) / 2;

通过AdjustDown函数和一个for循环完成上面步骤，时间复杂度O（n）

for (int i = ((n-1)-1)/2; i >= 0; --i) 
//(n-1)是拿到树最后一个节点,然后再根据公式Parent = (Child - 1) / 2;
{
	AdjustDown(a, size, i);
}

2.调整堆

创建堆后要调整堆，升序建大堆，降序建小堆
以大堆为例
建了大堆之后,循环N次 ，进行N次调整堆操作，每一次调整 堆得到的最大值，将此值和数组的最后一个元素进行交换，交换减小数组的长度（最后被减小的那几个值不参与堆的调整），直到最后一个元素，就完成了堆的排序.

void HeapSort(int* a, int n)
{
	// 建堆 （大堆）or  （小堆）
	for (int i = 1; i < n; i++)
	{
		AdjustUp(a, i);
	}
int end = n - 1;
while (end > 0)
{
	Swap(&a[0], &a[end]);  //交换
	AdjustDown(a, end, 0); //向下调整
	--end;   //换下来的最后一个数不计入堆中
}

四.Topk问题

有1000个数据,你要找前100个大的数据,那么你先随便拿100个数据(无论其大小多少)建小堆,然后另外900个数据依次与堆顶的最小数据进行比较,比它大就替换,然后再调整堆,这样1000个数据都参与了对比,对比了900次,900个最小的被拿走,剩下的100个一定是最大的,再进行堆排序

void CreateNDate()
{
	// 造数据
	int n = 10000000;
	srand(time(0));
	const char* file = "data.txt";
	FILE* fin = fopen(file, "w");
	if (fin == NULL)
	{
		perror("fopen error");
		return;
	}

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

	fclose(fin);
}

void TestTopK(const char* filename, int k)
{
	// 1. 建堆--用a中前k个元素建堆
	FILE* fout = fopen(filename, "r");
	if (fout == NULL)
	{
		perror("fopen fail");
		return;
	}

	int* minheap = (int*)malloc(sizeof(int) * k);
	if (minheap == NULL)
	{
		perror("malloc fail");
		return;
	}

	for (int i = 0; i < k; i++)
	{
		fscanf(fout, "%d", &minheap[i]);
	}

	// 前k个数建小堆
	for (int i = (k-2)/2; i >=0 ; --i)
	{
		AdjustDown(minheap, k, i);
	}


	// 2. 将剩余n-k个元素依次与堆顶元素交换，不满则则替换
	int x = 0;
	while (fscanf(fout, "%d", &x) != EOF)
	{
		if (x > minheap[0])
		{
			// 替换你进堆
			minheap[0] = x;
			AdjustDown(minheap, k, 0);
		}
	}


	for (int i = 0; i < k; i++)
	{
		printf("%d ", minheap[i]);
	}
	printf("\n");

	fclose(fout);
}


int main()
{
	CreateNDate();
	TestTopK("data.txt", 5);
	return 0;
}

总结

提示：这里对文章进行总结：
例如：以上就是今天要讲的内容，本文仅仅简单介绍了pandas的使用，而pandas提供了大量能使我们快速便捷地处理数据的函数和方法。