深入理解堆（下）

1、堆的插入

  　将需要插入的元素放到数组的末尾，与其父节点比较，进行向上调整算法，直到满足堆的结构。
  　以小根堆举例，给定数组a[]= {5,11,7,2,3,17}，输插入数字1，如图所示：

1.1代码

//向上调整算法
void ADjustUp(int*a, int child){
	int parent = (child - 1) / 2;

	while (child>=0)
	{
		if (a[child] < a[parent])
		{
			int tmp = a[parent];
			a[parent] = a[child];
			a[child] = tmp;
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}
void HeapPush(Heap* hp, HpDataType x)
{
	//空间不够进行增容
	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);
}

1.2结果

建堆：2 3 7 11 5 17
插入之后：1 3 2 11 5 17 7

2、堆的删除

  　对于堆而言，删除是针对于根节点而言，就是删除堆顶的数据，将堆顶的数据根最后一个数据交换，然后删除数组最后一个数据，再进行向下调整算法。
  　继续上个例子，删除堆顶数字–1，如图所示：

2.1代码

void HeapPop(Heap* hp)
{
	//交换堆顶和末尾
	HpDataType tmp = hp->_a[0];
	hp->_a[0] = hp->_a[hp->_size-1];
	hp->_a[hp->_size - 1] = tmp;

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

2.2结果

建堆：1 3 2 11 5 17 7
插入之后：2 3 7 11 5 17

3、取堆顶的数据和判空

3.1代码

//取堆顶
HpDataType HeapTop(Heap* hp)
{
	return hp->_a[0];
}
//判空
HpDataType HeapEmpty(Heap*hp)
{
	return hp->_size == 0 ? 1 : 0;
}

4、topK问题

  　找出N个数里面最大/最小的前K个问题。比如游戏里面的英雄熟练度排名之类的，美食前几的商家之类的问题都是topK问题。
  　注意：
找最大的前K个，要建前K个数的小堆；找最小的前K个数，要建前K个数的大堆。然后和剩下的数组里面比较，若小于则删除堆顶并且插入新比较的数。

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<windows.h>
#include<string.h>
#include<malloc.h>

//小堆
typedef int HpDataType;
typedef struct Heap
{
	HpDataType* _a;
	size_t _size;
	size_t _capacity;

}Heap;
void ADjustDown(HpDataType* a, size_t n, int root);
void Heapcreate(Heap* hp, HpDataType* a, size_t n);
void HeapPush(Heap* hp, HpDataType x);
void HeapPop(Heap* hp);
HpDataType	HeapTop(Heap* hp);
void HeapPrint(Heap* hp);


void ADjustDown(HpDataType* a,size_t n, int root)
{
	int parent = root;
	int child = 2 * parent + 1;
	while (child<n)
	{
		//if (child + 1<n&&a[child]<a[child + 1])//大堆
		if (child + 1<n&&a[child]>a[child + 1])
		{
			child++;
		}
		//调整:1、孩子比父亲小则交换，继续下调   2、孩子比父亲大，则终止
		//if (a[parent]<a[child])//大堆
		if (a[parent]>a[child])
		{
			HpDataType tmp = a[parent];
			a[parent] = a[child];
			a[child] = tmp;
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}
//向上调整算法
void ADjustUp(int*a, int child)
{
	int parent = (child - 1) / 2;
	while (a[parent] > a[child])
	{
		int tmp = a[parent];
		a[parent] = a[child];
		a[child] = tmp;
		child = parent;
		parent = (child - 1) / 2;
	}
}
//建堆
void Heapcreate(Heap* hp, HpDataType* a, size_t n)
{
	//把数组拷贝到hp中
	hp->_a = (HpDataType*)malloc(sizeof(HpDataType)*n);
	memcpy(hp->_a, a, sizeof(HpDataType)*n);
	hp->_size = n;
	hp->_capacity = n;

	//建堆:第一个调的位置是最后一个节点的父亲
	for (int i = (n - 1 - 1) / 2; i >= 0; --i)
	{
		ADjustDown(hp->_a, hp->_size, i);
	}
}
//堆的插入
void HeapPush(Heap* hp, HpDataType x)
{
	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)
{
	//交换堆顶和末尾
	HpDataType tmp = hp->_a[0];
	hp->_a[0] = hp->_a[hp->_size-1];
	hp->_a[hp->_size - 1] = tmp;

	hp->_size--;
	ADjustDown(hp->_a, hp->_size, 0);
}
//取堆顶
HpDataType	HeapTop(Heap* hp)
{
	return hp->_a[0];
}
//打印
void HeapPrint(Heap*hp)
{
	for (int i = 0; i < hp->_size; ++i)
	{
		printf("%d ",hp->_a[i]);
	}
	printf("\n");
}
void PrintTopK(int* a, int n, int k)//n是数组的总大小 k就是前k名
{
	Heap hp2;
	Heapcreate(&hp2, a, k);
	//先从数组的前十个建成一个小堆
	
	for (int i = k; i < n; i++)
	{
		if (HeapTop(&hp2) < a[i])
		{
			HeapPop(&hp2);
			HeapPush(&hp2,a[i]);
		}
	}
		HeapPrint(&hp2);
}

void TestTopk()
{
	int n = 20;
	int* a = (int*)malloc(sizeof(int)*n);
	srand(time(0));
	for (size_t i = 0; i < n; ++i)
	{
		a[i] = rand() % 50;
	}
	
	a[1] = 1000 + 1;
	a[5] = 1000 + 2;
	a[13] = 1000 + 3;
	a[8] = 1000 + 4;
	a[9] = 1000 + 5;
	a[10] = 1000 + 6;
	a[17] = 1000 + 7;
	a[7] = 1000 + 8;
	a[2] = 1000 + 9;
	a[3] = 1000 + 10;
	
	PrintTopK(a, n, 10);
}
int main()
{  
    TestTopk();
	system("pause");
	return 0;
}