二叉树（3）——堆的应用

垂柳斜下茉莉雨

已于 2024-03-02 22:59:41 修改

阅读量851

点赞数 28

分类专栏：数据结构文章标签：算法数据结构

于 2024-02-07 02:19:16 首次发布

本文链接：https://blog.csdn.net/linxiaogua123/article/details/136061540

版权

数据结构专栏收录该内容

25 篇文章 0 订阅

订阅专栏

1 堆排序

堆排序是一个选择排序

这里我们可以直接用前面所讲的，先将数组中的数根据插入都插入到堆里，然后再一个一个取Top堆顶元素。但是我们要知道，这样做有两个不好的地方：

如果我们事先并没有实现堆的插入删除，就要重新写代码
空间复杂度太高

这里我们可以用以下思路。

思路

1、建堆：直接将数组建堆。先假设第一个数就在堆里，然后把后面的数依次向上调整。

本质：模拟堆插入的过程
⭐升序建大堆，降序建小堆要重点理解!!!
时间复杂度：N*logN

2、向下调整：先将首尾交换，然后将交换过来的新根向下调整。（最后一个元素不参与调整）一直循环这个过程，直到所有的数都交换完毕。

本质：模拟堆删除的过程
时间复杂度：(N-1)*logN

总时间复杂度：O(N*logN)

代码实现

这里举例升序。

向上调整建堆

void HeapSort(int* a, int n)
{
	// O(N*logN)
    //向上调整建堆
	/*for (int i = 1; i < n; i++)
	{
		AdjustUp(a, i);
	}*/

	// O(N)
    //向下调整建堆
	for (int i = (n-1-1)/2; i >= 0; --i)
	{
		AdjustDown(a, n, i);
	}

	int end = n - 1;
	while (end > 0)
	{
		Swap(&a[0], &a[end]);
		AdjustDown(a, end, 0);
		--end;
	}
}

int main()
{
	int a[10] = { 4, 6, 2, 1, 5, 8, 2, 9 };
	int size = sizeof(a) / sizeof(a[0]);
	HeapSort(a, size);

	for (int i = 0; i < size; i++)
	{
		printf("%d ", a[i]);
	}
	return 0;
}

大堆的向上向下调整代码实现

void Swap(HPDataType* p1, HPDataType* p2)
{
	HPDataType tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

void AdjustUp(HPDataType* a, int child)
{
	int parent = (child - 1) / 2;
	//while (parent >= 0) 不能这样写，因为parent不可能<0
	while (child > 0) //用child判断
	{
		if (a[child] > a[parent])
		{
			Swap(&a[child], &a[parent]);
			//往上走
			child = parent;
			parent = (child - 1) / 2;
			//child = (child - 1) / 2;
			//parent = (parent - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

void AdjustDown(int* a, int size, int parent)
{
	int 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;
		}
	}

}

注意

向下调整建堆

在实现HeapSort函数时，可以直接用向上调整建堆，也就是思路里写的那种办法。但是这里用向下调整建堆更加方便。从倒数第一个非子叶，也就是最后一个节点的父亲开始依次（以上的数）向下调整，这样就能建立出来一个小堆或者大堆。

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

两大优势：

可以只写一个向下调整就解决了堆排序，而不需要用到向上排序
时间复杂度为O(N)，效率高

2 Top K问题

TOP-K 问题：即求数据结合中前 K 个最大的元素或者最小的元素，一般情况下数据量都比较大 。比如：专业前10 名、世界 500 强、富豪榜、游戏中前 100 的活跃玩家等。

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

思路

1.、用数据集合中前K个元素来建堆

前k个最大的元素，则建小堆
前k个最小的元素，则建大堆

2、用剩余的N-K个元素依次与堆顶元素来比较，不满足则替换堆顶元素。

3、将剩余N-K个元素依次与堆顶元素比完之后，堆中剩余的K个元素就是所求的前K个最小或者最大的元素。

代码实现

这里求前k个最大的元素——小堆。向上向下调整的代码不再赘述。

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)
	{
        //写10000000个小于10000000的数
		int x = (rand()+i) % 10000000;
		fprintf(fin, "%d\n", x);
	}

	fclose(fin);
}

void PrintTopK(const char* file, int k)
{
	FILE* fout = fopen(file, "r");
	if (fout == NULL)
	{
		perror("fopen error");
		return;
	}

	// 开辟数组空间，建一个k个数小堆
	int* minheap = (int*)malloc(sizeof(int) * k);
	if (minheap == NULL)
	{
		perror("malloc error");
		return;
	}

	// 读取前k个，建小堆
	for (int i = 0; i < k; i++)
	{
		fscanf(fout, "%d", &minheap[i]);
		AdjustUp(minheap, i);
	}

	int x = 0;
    //读取后面的数比较进堆
	while (fscanf(fout, "%d", &x) != EOF)
	{
		if (x > minheap[0])
		{
			minheap[0] = x;
			AdjustDown(minheap, k, 0);
		}
	}

    //打印前k个数
	for (int i = 0; i < k; i++)
	{
		printf("%d ", minheap[i]);
	}
	printf("\n");

	free(minheap);
	fclose(fout);
}

int main()
{
	CreateNDate(); //创造数据
	PrintTopK("Data.txt", 5); //取文件中最大的前5个数

	return 0;
}