堆的构建和操作

最新推荐文章于 2023-05-27 16:57:40 发布

嚞譶

最新推荐文章于 2023-05-27 16:57:40 发布

阅读量399

点赞数 2

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

本文链接：https://blog.csdn.net/qq_64404343/article/details/128364082

版权

初阶数据结构专栏收录该内容

7 篇文章 0 订阅

订阅专栏

堆是什么

堆是一种完全二叉树，采用顺序结构存储。

堆的操作与构建

堆有两种，大堆和小堆。

大堆：根大于左右子树

小堆：根小于左右子树

堆结构体定义

typedef int HPDataType;
typedef struct Heap
{
	HPDataType* _a;
	int _size;
	int _capacity;
}Heap;

初始化

void HeapInit(Heap* hp)
{
	assert(hp);
	hp->_a = NULL;
	hp->_capacity = hp->_size = 0;
}

插入元素

每在堆尾插入一个元素，就要把它重新调整成堆，因此，我们可以实现一个向上调整的函数。

以小堆为例：

向上调整：从当前位置向上调整，如果子节点小于根节点，就要将他们交换，直到子节点大于根节点或子节点=0，即调整到堆顶。这是两种结束情况。

void adjustup(HPDataType* a, int child)
{
	//向上调整
	assert(a);
	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(Heap* hp, HPDataType x)
{
	assert(hp);
	//满了要扩容
	if (hp->_capacity == hp->_size)
	{
		int newcapacity = hp->_capacity == 0 ? 4 : hp->_capacity * 2;
		HPDataType* tmp =(HPDataType*) realloc(hp->_a, sizeof(HPDataType)*newcapacity);
		if (tmp == NULL)
		{
			perror("realloc");
			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)
{//向下调整建立堆
	assert(a);
	int child = parent * 2 + 1;
	while (child<n)//!!一定要注意结束条件！！
	{
		if (child + 1 < n && a[child + 1] < a[child])
		{
			child++;
		}
		if (a[child] < a[parent])
		{
			swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}
void HeapPop(Heap* hp)
{
	assert(hp);
	assert(!HeapEmpty(hp));
	//把堆顶和堆底元素互换，然后删除堆底，不破坏堆的结构
	swap(&hp->_a[hp->_size - 1], &hp->_a[0]);
	hp->_size--;
	adjustdown(hp->_a, hp->_size, 0);
}

取堆顶数据

HPDataType HeapTop(Heap* hp)
{
	assert(hp);
	assert(!HeapEmpty(hp));
	return hp->_a[0];
}

堆元素个数

int HeapSize(Heap* hp)
{
	assert(hp);
	return hp->_size;
}

判断堆是否为空

int HeapEmpty(Heap* hp)
{
	assert(hp);
	return hp->_size == 0;
}

堆的销毁

void HeapDestory(Heap* hp)
{
	assert(hp);
	free(hp->_a);
	hp->_a = NULL;
	hp->_capacity = hp->_size = 0;
}

堆的构建

很多情况，会让我们用一个数组建堆，所以我们可以将堆的构建直接封装成函数。

void HeapCreate(Heap* hp, HPDataType* a, int n)
{
	assert(hp);
	hp->_a =(HPDataType*) malloc(sizeof(HPDataType) * n);//开空间
	if (hp->_a == NULL)
	{
		perror("malloc");
		exit(-1);
	}
	hp->_capacity = hp->_size = n;
	memcpy(hp->_a, a, sizeof(HPDataType) * n);//拷贝元素
	for (int i = (n - 1 - 1) / 2; i >= 0; i--)
	{//向下调整建堆
		adjustdown(hp->_a, n, i);
	}
}

TopK问题

TopK问题：找出一组元素中最大或最小的k个元素。

以最大k个元素为例：

解题思路：先根据前k个元素建立一个小堆，然后将剩余的n-k个元素依次与堆顶元素比较，

如果大于堆顶，就交换，然后调整，最后堆中k个元素就是最大的k个元素。

若找出最小元素，则利用大堆。

void PrintTopK(int* a, int n, int k)
{
	Heap hp;
	HeapCreate(&hp, a, k);
	for (int i = k; i < n; i++)
	{
		int x = HeapTop(&hp);
		if (a[i] > x)
		{
			HeapPop(&hp);
			HeapPush(&hp, a[i]);
			/*swap(&a[i], &x);
			adjustdown(&hp, k, 0);*/
		}
	}
	for (int i = 0; i < k; i++)
	{
		printf("%d ", HeapTop(&hp));
		HeapPop(&hp);
	}
}

堆排序

堆排序思路：降序：先将数组调整成小堆，然后将堆顶与堆底互换，删除堆底元素。

升序：先将数组调整成大堆，然后将堆顶与堆底互换，删除堆底元素。

void HeapSort(int* a, int n)
{
	assert(a);
	//先调整成堆
	for (int i = 1; i < n; i++)
	{
		adjustup(a, i);
	}
	//然后将首尾元素互换，看成删除尾元素，然后继续调整
	for (int end = n-1; end > 0; end--)
	{
		swap(&a[0], &a[end]);
		adjustdown(a, end, 0);
	}
}