堆的实现

堆的性质

• 堆中某个节点的值总是不大于或不小于其父亲节点的值；
• 堆总是一颗完全二叉树。

堆的实现

头文件

#pragma once 

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

typedef int HPDataType;

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

// 堆的构建
void HeapCreate(Heap* hp, HPDataType* a, int n);

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

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

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

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

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

// 堆的判空
int HeapEmpty(Heap* hp);

// 堆的打印
void HeapPrintf(Heap* hp);

// 对数组进行堆排序
void HeapSort(int* a, int n);

// TopK问题：找出N个数里面最大/最小的前K个问题。
// 比如：未央区排名前10的泡馍，西安交通大学王者荣耀排名前10的韩信，全国排名前10的李白。等等问题都是Topk问题，
// 需要注意：
// 找最大的前K个，建立K个数的小堆
// 找最小的前K个，建立K个数的大堆
void PrintTopK(int* a, int n, int k);

函数实现

#include"Heap.h"

void Swap(HPDataType* left, HPDataType *right)
{
	HPDataType tmp = *left;
	*left = *right;
	*right = tmp;
}

void AdjustDown(HPDataType* a, int n, int root)
{
	int parent = root;
	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 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 HeapCreate(Heap* hp, HPDataType* a, int n)
{
	assert(hp && a);
	hp->_a = (HPDataType*)malloc(sizeof(HPDataType)*n);
	hp->_size = hp->_capacity = n;
	memcpy(hp->_a, a, sizeof(HPDataType)*n);
	for (int i = (n - 2) / 2; i > 0; --i)
	{
		AdjustDown(a, n, i);
	}
	HeapPrintf(hp);
}

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

// 堆的插入
void HeapPush(Heap* hp, HPDataType x)
{
	assert(hp);
	//空间不够增容
	if (hp->_size == hp->_capacity)
	{
		size_t newcapacity = hp->_capacity * 2;
		hp->_a = (HPDataType*)realloc(hp->_a,sizeof(HPDataType)*newcapacity);
		hp->_capacity = newcapacity;
	}

	hp->_a[hp->_size] = x;
	hp->_size++;

	//向上调整
	AdjustUp(hp->_a, hp->_size - 1);
}

// 堆的删除
void HeapPop(Heap* hp)
{
	Swap(&hp->_a[0], &hp->_a[hp->_size - 1]);
	hp->_size--;

	AdjustDown(hp->_a, hp->_size, 0);
}

// 取堆顶的数据
HPDataType HeapTop(Heap* hp)
{
	return hp->_a[0];
}

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

// 堆的判空
int HeapEmpty(Heap* hp)
{
	assert(hp);
	return hp->_size == 0 ? 1 : 0;
}

void HeapPrintf(Heap* hp)
{
	for (int i = 0; i < hp->_size; ++i)
	{
		printf("%d ", hp->_a[i]);
	}
	printf("\n");
}

// 对数组进行堆排序
void HeapSort(int* a, int n)
{
	// 排升序需要建大堆：
	// 因为每次都会把堆顶元素拿出来放到当前堆的最后一个位置
	// 相当于每次都会把剩余元素中的最大值（即堆顶元素）找出来
	// 放到它该有的位置（当前堆的最后一个位置）
	// 建堆
	for (int i = (n - 2) / 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;
	}
}

// TopK问题：
// 找最大的前K个，建立K个数的小堆
// 找最小的前K个，建立K个数的大堆
//1.建立小堆，找最大的前K个
//思路：建立一个K大小的小堆，堆顶是最小的元素，接下来的数a[k]比堆顶大
//那就说明这个数要替代了堆顶的数了，当他替换堆顶元素之后进行一次向下调整，
//这时候堆里最小的元素又跑到堆顶了，只要比他大那就把它替换掉，
//当整个数组遍历完毕之后，堆里的元素就是最大的k个元素了。
void PrintTopK(int* a, int n, int k)
{
	int num = n;
	for (int i = (k - 2) / 2; i > 0; --i)
	{
		AdjustDown(a, k, i);
	}

	for (int i = k; i < num; ++i)
	{
		if (a[0]<a[i])
		{
			Swap(&a[0], &a[i]);
		}
		AdjustDown(a, k, 0);
	}

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

//2.建大堆，找最小的前K个
void AdjustDownBig(HPDataType* a, int n, int root)
{
	int parent = root;
	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 PrintTopKSmall(int* a, int n, int k)
{
	int num = n;
	for (int i = (k - 2) / 2; i > 0; --i)
	{
		AdjustDownBig(a, n, i);
	}

	for (int i = k; i < num; ++i)
	{
		if (a[0]>a[i])
		{
			Swap(&a[0], &a[i]);
		}
		AdjustDownBig(a, k, 0);
	}

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

调用函数

#include"Heap.h"

int main()
{
	int arr[10] = { 23, 56, 78, 9, 3, 4, 66, 88, 34, 25 };
	/*HeapCreate(&hp, arr, 10);
	HeapSort(arr, 10);*/
	PrintTopK(arr,10,3);
	PrintTopKSmall(arr,10,3);

	system("pause");
	return 0;
}