数据结构_第十关：二叉树的顺序结构——堆

目录

1. 二叉树的顺序结构

2.堆的概念及结构

3.堆的实现

3.1堆向下调整算法

 3.2堆的创建

3.3堆的插入

3.4建堆的复杂度

3.5堆的删除

4.堆的代码实现

4.1堆的定义

4.2堆的函数实现

1）堆的初始化

2）堆的销毁

3）堆的插入

4）堆的删除

5）取堆顶的数据

6）堆的数据个数

7）堆的判空

8）堆的构建（给你一个数组，用给定的数组建堆）（不用push建堆）

4.3堆的源代码和测试（vs2022下编译）

5.堆排序

6.TOP-K问题

---

1. 二叉树的顺序结构

普通的二叉树是不适合用数组来存储的，因为可能会存在大量的空间浪费。而完全二叉树更适合使用顺序结 构存储。现实中我们通常把堆（一种二叉树）使用顺序结构的数组来存储，需要注意的是  这里的堆  和  操作系统虚拟进程地址空间中的堆  是两回事，一个是数据结构，一个是操作系统中管理内存的一块区域分段。

2.堆的概念及结构

如果有一个关键码的集合K = { k0，k1 ，k2 ，…，kn-1}，把它的所有元素按完全二叉树的顺序存储方式存储 在一个一维数组中，并满足：i=0，1，2...

则称为小堆(或大堆)。将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。

人话说就是：
大堆：树中所有 父节点  都  大于或等于  子节点
小堆：树中所有 父节点  都  小于或等于  子节点

孩子和小标之前有一个关系：

• leftchild = parent*2+1
• rightchild = parent*2+2
• parent = (child-1)/2

 选择题

1.下列关键字序列为堆的是：（）
A 100,60,70,50,32,65
B 60,70,65,50,32,100
C 65,100,70,32,50,60
D 70,65,100,32,50,60
E 32,50,100,70,65,60
F 50,100,70,65,60,32

2.已知小根堆为8,15,10,21,34,16,12，删除关键字 8 之后需重建堆，在此过程中，关键字之间的比较次
数是（）。
A 1
B 2
C 3
D 4

3.一组记录排序码为(5 11 7 2 3 17),则利用堆排序方法建立的初始堆为
A(11 5 7 2 3 17)
B(11 5 7 2 17 3)
C(17 11 7 2 3 5)
D(17 11 7 5 3 2)
E(17 7 11 3 5 2)
F(17 7 11 3 2 5)

4.最小堆[0,3,2,5,7,4,6,8],在删除堆顶元素0之后，其结果是（）
A[3，2，5，7，4，6，8]
B[2，3，5，7，4，6，8]
C[2，3，4，5，7，8，6]
D[2，3，4，5，6，7，8]

答案：

A

C

C

C

3.堆的实现

3.1堆向下调整算法

现在我们给出一个数组，逻辑上看做一颗完全二叉树。

我们通过从根节点开始的向下调整算法可以把它调整成一个小堆。

向下调整算法：

• 小堆：父节点 比 孩子节点 小，往下换，换孩子中大的那个
• 大堆：父节点 比 孩子结点 大，往下换，换孩子中小的那个

int array[] = {27,15,19,18,28,34,65,49,25,37};

 3.2堆的创建

下面我们给出一个数组，这个数组逻辑上可以看做一颗完全二叉树，但是还不是一个堆，现在我们通过算法，把它构建成一个堆。

这里我们插入每插入一个数，就和父节点进行比较，建立一个大堆如下：

3.3堆的插入

先插入一个10到数组的尾上，再进行向上调整算法，直到满足堆。

3.4建堆的复杂度

因为堆是完全二叉树，而满二叉树也是完全二叉树，此处为了简化使用满二叉树来证明
(时间复杂度本来看的 就是近似值，多几个节点不影响最终结果)

向上调整建堆的时间复杂度为O(N*logN)。

向下调整建堆的时间复杂度为O(N)。

所以堆的创建一般选取像下调整建堆

最少为0，
最多为：二叉树的层数H

3.5堆的删除

删除堆是删除堆顶的数据，

堆的删除不能往前挪动覆盖，因为首先数组的挪动覆盖 比较慢，而后，堆的关系会乱。

删最后一个就不会改变堆的关系所以，将堆顶的数据根最后一个数据一换，然后删除数组最后一个数据，再进行向下调整算法。

4.堆的代码实现

4.1堆的定义

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

//打印
void HeapPrint(HP* hp);

// 堆的初始化
void HeapInit(HP* hp);

// 堆的销毁
void HeapDestory(HP* hp);

// 堆的插入
void HeapPush(HP* hp, HPDataType x);

// 堆的删除
void HeapPop(HP* hp);

// 取堆顶的数据
HPDataType HeapTop(HP* hp);

// 堆的数据个数
int HeapSize(HP* hp);

// 堆的判空
bool HeapEmpty(HP* hp);

//堆的构建（给你一个数组，用给定的数组建堆）
void HeapCreate(Heap* hp, HPDataType* a, int n);

4.2堆的函数实现

1）堆的初始化

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

2）堆的销毁

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

3）堆的插入

void AdjustUp(HPDataType* a, int child)
{
	int parent = (child - 1) / 2;

	while (child > 0)
	{
		//这里换为 < 是小堆的创建
		if (a[child] > a[parent])
		{
			//交换
			HPDataType temp = a[child];
			a[child] = a[parent];
			a[parent] = temp;

			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}
// 堆的插入
void HeapPush(HP* hp, HPDataType x)
{
	assert(hp);
	
	//扩容
	if (hp->size == hp->capacity)
	{
		int newcapacity = hp->capacity == 0 ? 4 : hp->capacity * 2;
		HPDataType* tmp = (HPDataType*)realloc(hp->a, sizeof(HPDataType) * newcapacity);
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(-1);
		}

		hp->a = tmp;
		hp->capacity = newcapacity;
	}
	hp->a[hp->size] = x;
	hp->size++;
	// 向上调整
	AdjustUp(hp->a, hp->size - 1);
}

原理可参考 3.3

先循环判断子节点和父节点的大小，然后做向上调整操作，

4）堆的删除

//交换
void swap(HPDataType* p1, HPDataType* p2)
{
	HPDataType temp = *p1;
	*p1 = *p2;
	*p2 = temp;
}
//像下调整
void AdjustDown(HPDataType* a, int n, int parent)
{
	//默认认为左孩子大
	int child = parent * 2 + 1;
	//超过数组大小
	while (child < n)
	{
		//确认child指向大的孩子
		if (child < n && a[child + 1] > a[child])
		{
			++child;
		}
		//孩子大于父亲，交换,继续调整
		if (a[child] > a[parent])
		{
			swap(&a[parent], &a[child]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}
// 堆的删除
void HeapPop(HP* hp)
{
	assert(hp);
	assert(hp->size > 0);

	//交换
	swap(&hp->a[0], &hp->a[hp->size - 1]);

	hp->size--;

	AdjustDown(hp->a, hp->size, 0);
}

5）取堆顶的数据

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

6）堆的数据个数

int HeapSize(HP* hp)
{
	assert(hp);
	return hp->size;
}

7）堆的判空

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

8）堆的构建（给你一个数组，用给定的数组建堆）（不用push建堆）

// 堆的构建（给你一个数组，用给定的数组建堆）（不用push建堆）
void HeapCreate(Heap* hp, HPDataType* a, int n)
{
	assert(hp);
	hp->a = (HPDataType*)malloc(sizeof(HPDataType) * n);
	if (hp->a == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	//把传过来的数组a，拷贝给hp->a,
	memcpy(hp->a, a, sizeof(HPDataType) * n);
	hp->size = hp->capacity = n;

	//建堆算法（向下调整）
	for (int i = (n - 1 - 1) / 2;i >= 0;--i)
	{
		AdjustDown(hp->a, n, i);
	}
}

4.3堆的源代码和测试（vs2022下编译）

#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
#include<string.h>
#include<stdbool.h>






//堆的声明

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

//打印
void HeapPrint(HP* hp);

// 堆的初始化
void HeapInit(HP* hp);

// 堆的销毁
void HeapDestory(HP* hp);

// 堆的插入
void HeapPush(HP* hp, HPDataType x);

// 堆的删除(删除堆顶元素)
void HeapPop(HP* hp);

// 取堆顶的数据
HPDataType HeapTop(HP* hp);

// 堆的数据个数
int HeapSize(HP* hp);

// 堆的判空
bool HeapEmpty(HP* hp);

// 堆的构建（给你一个数组，用给定的数组建堆）（不用push建堆）,n是数组大小
void HeapCreate(Heap * hp, HPDataType * a, int n);






//堆的定义
#include"heap.h"

//交换
void swap(HPDataType* p1, HPDataType* p2)
{
	HPDataType temp = *p1;
	*p1 = *p2;
	*p2 = temp;
}

// 打印
void HeapPrint(HP* hp)
{
	assert(hp);
	for (int i = 0;i < hp->size;i++)
	{
		printf("%d ", hp->a[i]);
	}
	printf("\n");
}

// 堆的初始化
void HeapInit(HP* hp)
{
	assert(hp);
	hp->a = NULL;
	hp->size = hp->capacity = 0;
}

// 堆的销毁
void HeapDestory(HP* 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[child] > a[parent])
		{
			//交换
			swap(&a[child],&a[parent]);

			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}
// 堆的插入
void HeapPush(HP* hp, HPDataType x)
{
	assert(hp);
	
	//扩容
	if (hp->size == hp->capacity)
	{
		int newcapacity = hp->capacity == 0 ? 4 : hp->capacity * 2;
		HPDataType* tmp = (HPDataType*)realloc(hp->a, sizeof(HPDataType) * newcapacity);
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(-1);
		}

		hp->a = tmp;
		hp->capacity = newcapacity;
	}
	hp->a[hp->size] = x;
	hp->size++;
	// 向上调整
	AdjustUp(hp->a, hp->size - 1);
}

//向下调整
void AdjustDown(HPDataType* a, int n, int parent)
{
	//默认认为左孩子大
	int child = parent * 2 + 1;
	//超过数组大小
	while (child < n)
	{
		//确认child指向大的孩子
		if (child < n && a[child + 1] > a[child])    //第一处：a[child + 1] > a[child]
		{
			++child;
		}

		//孩子大于父亲，交换,继续调整
		if (a[child] > a[parent])    //第二处：a[child] > a[parent]
		{
			swap(&a[parent], &a[child]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}

    //将第一处和第二处的>换位<则是建小堆
}

// 堆的删除
void HeapPop(HP* hp)
{
	assert(hp);
	assert(hp->size > 0);

	//交换
	swap(&hp->a[0], &hp->a[hp->size - 1]);

	hp->size--;

	AdjustDown(hp->a, hp->size, 0);
}

// 取堆顶的数据
HPDataType HeapTop(HP* hp)
{
	assert(hp);
	assert(hp->size > 0);
	return hp->a[0];
}

// 堆的数据个数
int HeapSize(HP* hp)
{
	assert(hp);
	return hp->size;
}

// 堆的判空
bool HeapEmpty(HP* hp)
{
	assert(hp);
	return hp->size == 0;
}

// 堆的构建（给你一个数组，用给定的数组建堆）（不用push建堆）
void HeapCreate(Heap* hp, HPDataType* a, int n)
{
	assert(hp);
	hp->a = (HPDataType*)malloc(sizeof(HPDataType) * n);
	if (hp->a == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	//把传过来的数组a，拷贝给hp->a,
	memcpy(hp->a, a, sizeof(HPDataType) * n);
	hp->size = hp->capacity = n;

	//建堆算法（向下调整）
	for (int i = (n - 1 - 1) / 2;i >= 0;--i)
	{
		//这里的AdjustDown是建立的大堆，若要减小堆，调整该函数里面的符号（函数里面有提示）
		AdjustDown(hp->a, n, i);
	}
}






//测试

void text1()
{
	HP hp;
	HeapInit(&hp);
	HPDataType array[] = { 27,15,19,18,28,34,65,49,25,37 };
	//用Push的方法建堆，是向上建堆，时间复杂度是O(n*logn);
	for (int i = 0;i < sizeof(array) / sizeof(HPDataType);i++)
	{
		HeapPush(&hp, array[i]);
	}
	HeapPrint(&hp);

	HeapPop(&hp);
	HeapPrint(&hp);

	//取堆里面最大的五个数
	int k = 5;
	while (k--)
	{
		printf("%d ", HeapTop(&hp));
		HeapPop(&hp);
	}

	HeapDestory(&hp);
}

void text2()
{
	HP hp;
	HPDataType array[] = { 27,15,19,18,28,34,65,49,25,37 };
	HeapCreate(&hp, array, sizeof(array) / sizeof(int));

	HeapPrint(&hp);

}

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

5.堆排序

• 排升序，建大堆
• 排降序，建小堆

算法思想：堆排序和堆删除的算法思想一样，都用到了堆的向下调整算法

算法核心：用数组的最后一个元素（size位置）与数组首元素进行交换，并将数组的size--；
                  使得下次交换时，最后一个位置的元素不受影响

具体步骤如下：以数组array={17，20，8，16，5，3}为例：（字有点丑，大家看懂就行）

 

代码如下： 

//交换
void swap(HPDataType* p1, HPDataType* p2)
{
	HPDataType temp = *p1;
	*p1 = *p2;
	*p2 = temp;
}
//像下调整（数组、数组大小、父节点下标）
void AdjustDown(HPDataType* a, int n, int parent)
{
	//默认认为左孩子大
	int child = parent * 2 + 1;
	//超过数组大小
	while (child < n)
	{
		//确认child指向大的孩子
		if (child < n && a[child + 1] > a[child])    //第一处：a[child + 1] > a[child]
		{
			++child;
		}

		//孩子大于父亲，交换,继续调整
		if (a[child] > a[parent])    //第二处：a[child] > a[parent]
		{
			swap(&a[parent], &a[child]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}

    //将第一处和第二处的>换位<则是建小堆
}
//堆排序
void HeapSort(int* a, int size)
{
	// 向下调整建堆 -- O(N)
	// 升序：建大堆
	for (int i = (size - 1 - 1) / 2; i >= 0; --i)
	{
		AdjustDown(a, size, i);
	}

	int end = size - 1;//(end表示数组需要与array[0]交换的下标位置)
	while (end > 0)
	{
		swap(&a[0], &a[end]);//交换array[0]和array[end]的位置
		AdjustDown(a, end, 0);//向下调整
		end--;
	}
}


int main()
{
	int array[] = { 27, 15, 19, 18, 28, 34, 65, 49, 25, 37 };
	HeapSort(array, sizeof(array) / sizeof(int));

    //打印
    for (int i = 0; i < sizeof(array) / sizeof(int); ++i)
	{
		printf("%d ", array[i]);
	}
	printf("\n");
	return 0;
}

6.TOP-K问题

TOP-K问题：即求数据结合中前K个最大的元素或者最小的元素，一般情况下数据量都比较大

 比如：专业前10名、世界500强、富豪榜、游戏中前100玩家等

对于Top-K问题，能想到的最简单直接的方式就是排序，但是：如果数据量非常大，排序就不太可取了(可能数据都不能一下子全部加载到内存中)。最佳的方式就是用堆来解决，基本思路如下：

1. 用数据集合中前K个元素来建堆
   • 前k个最大的元素，则建小堆
   • 前k个最小的元素，则建大堆
2. 用剩余的N-K个元素依次与堆顶元素来比较，不满足则替换堆顶元素

比如：N个数找最大的前K个：

• 方法一（传统方法）：建立一个N个数的大堆，Pop   K次，依次取堆顶
  • 时间复杂度：N+logN*K
  • 空间复杂度：O(1)
• 方法二：建立K个数的小堆，依次遍历数据，比堆顶数据大，就替换堆顶，再向下调整，
  最后最大的前K个数，就在小堆里面。
  • 时间复杂度：N+（N-K)*logK  ->  O(N*logK)
  • 空间复杂度：O(K)

这里给定n个数，求n个数里面最大的k个数（方法二的代码实现）

#include<stdio.h>
#include<stdlib.h>
#include<time.h>

void swap(int* p1, int* p2)
{
	int temp = *p1;
	*p1 = *p2;
	*p2 = temp;
}
//像下调整（数组、数组大小、父节点下标）
void AdjustDown(int* a, int n, int parent)
{
	//默认认为左孩子大
	int child = parent * 2 + 1;
	//超过数组大小
	while (child < n)
	{
		//确认child指向大的孩子
		if (child + 1 < n && a[child + 1] < a[child])
		{
			++child;
		}
		//孩子大于父亲，交换,继续调整

		if (a[child] < a[parent])
		{
			swap(&a[parent], &a[child]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

void TestHeap5()
{
	// 造数据
	int n, k;	//n为造数据的多少，k为选前几个最大的
	printf("请输入n和k:>");
	scanf("%d%d", &n, &k);

	//打开文件
	FILE* fin = fopen("data.txt", "w");
	if (fin == NULL)
	{
		perror("fopen fail");
		return;
	}

	//写文件
	srand(time(0));		//为了让rand()实现真随机，用时间戳给他一个种子
	//int randK = k;
	//写n个数据到文件data.txt中
	for (size_t i = 0; i < n; ++i)
	{
		int val = rand() % 100;
		fprintf(fin, "%d\n", val);
	}

	fclose(fin);

	//-------------------------------------------------------------------------//

	// 找topk

	//打开文件
	FILE* fout = fopen("data.txt", "r");
	if (fout == NULL)
	{
		perror("fopen fail");
		return;
	}

	//对数组扩容
	int* minHeap = (int*)malloc(sizeof(int) * k);
	if (minHeap == NULL)
	{
		perror("malloc fail");
		return;
	}

	//先读文件里面前k个数据并放入数组中
	for (int i = 0; i < k; ++i)
	{
		fscanf(fout, "%d", &minHeap[i]);
	}
	// 堆前k个数据建小堆
	for (int i = k - 1 - 1; i >= 0; --i)
	{
		AdjustDown(minHeap, k, i);
	}

	//文件的数据读取出来，保存到val值中，并与小堆堆顶的数据作比较
	int val = 0;
	while (fscanf(fout, "%d", &val) != EOF)
	{
		//大于堆顶数据，插入进去，并继续排小堆
		if (val > minHeap[0])
		{
			minHeap[0] = val;
			AdjustDown(minHeap, k, 0);
		}
	}

	//打印堆里面的数据
	for (int i = 0; i < k; ++i)
	{
		printf("%d ", minHeap[i]);
	}
	printf("\n");

	fclose(fout);
}

int main()
{
	TestHeap5();

	return 0;
}