向下調(diào)整算法
void* AdjustDown(HPDataType* a, size_t size, size_t root)
{
       size_t parent = root;
       size_t child = parent * 2 + 1;//默認(rèn)是左孩子
       while (child < size)
       {
              //1、選出左右孩子中小的那個(gè)，而且保證不會(huì)越界訪問(wèn)
              if (child + 1 < size && a[child + 1] < a[child])
              {
                      child++;//左孩子變?yōu)橛液⒆?
              }
              if (a[child]< a[parent])
              {
                      Swap(&a[child], &a[parent]);
                      parent = child;//繼續(xù)計(jì)算
                      child = parent * 2 + 1;//默認(rèn)還是計(jì)算左孩子
              }
              else
              {
                      break;
              }
       }
}

void Adjustup(HPDataType* a, size_t child)
{
       size_t parent = (child - 1) / 2;
       while (child > 0)
       {
              //小堆a(bǔ)[child] <a[parent],大堆a(bǔ)[child] > a[parent]時(shí)交換
              if (a[child] < a[parent])
              {
                      Swap(&a[child], &a[parent]);//因?yàn)槭侵羔槀鲄?，所以?amp;
                      child = parent;
                      parent = (child - 1) / 2;
              }
              else
              {
                      break;
              }
       }
}

#pragma once
// 小堆
#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
#include<stdbool.h>
typedef int HPDataType;
typedef struct Heap
{
	HPDataType* a;
	size_t size;
	size_t capacity;
}HP;
void PrintTopk(int* a, int n, int k);
void HeapInit(HP* php);//堆的初始化
void HeapDestory(HP* php);//堆的銷(xiāo)毀
void Swap(HPDataType* pa, HPDataType* pb);//交換
void HeapPrint(HP* php);
void AdjustDown(HPDataType* a, size_t size, size_t root);//堆的向下調(diào)整算法
//插入x以后，依舊保持堆
void HeapPush(HP* php, HPDataType x);
void Adjustup(HPDataType* a, size_t child);//堆的向上調(diào)整算法
//刪除堆頂?shù)臄?shù)據(jù)，（最小/最小）
void HeapPop(HP* php);
bool HeapEmpty(HP* php);
size_t HeapSize(HP* php);
HPDataType HeapTop(HP* php);

#include"Heap.h"
void HeapInit(HP* php)
{
	assert(php);
	php->a = NULL;
	php->size = php->capacity = 0;
}
void HeapDestory(HP* php)
{
	assert(php);
	free(php->a);
	php->a = NULL;
	php->size = php->capacity = 0;
}
void Swap(HPDataType* pa, HPDataType* pb)
{
	HPDataType tmp = *pa;
	*pa = *pb;
	*pb = tmp;
}
void HeapPrint(HP* php)
{
	assert(php);
	for (size_t i = 0; i < php->size; i++)
	{
		printf("%d ", php->a[i]);
	}
	printf("\n");
}
//涉及堆排序
void Adjustup(HPDataType* a, size_t child)
{
	size_t parent = (child - 1) / 2;
	while (child > 0)
	{
		//小堆a(bǔ)[child] <a[parent],大堆a(bǔ)[child] > a[parent]時(shí)交換
		if (a[child] < a[parent])
		{
			Swap(&a[child], &a[parent]);//因?yàn)槭侵羔槀鲄ⅲ砸?amp;
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}
void AdjustDown(HPDataType* a, size_t size, size_t root)
{
	size_t parent = root;
	size_t child = parent * 2 + 1;//默認(rèn)是左孩子
	while (child < size)
	{
		//1、選出左右孩子中小的那個(gè)，而且保證不會(huì)越界訪問(wèn)
		if (child + 1 < size && a[child + 1] < a[child])//建大堆時(shí)< 改 >
		{
			++child;//左孩子變?yōu)橛液⒆?
		}
		if (a[child] < a[parent])//建大堆時(shí)< 改 >
		{
			Swap(&a[child], &a[parent]);
			parent = child;//繼續(xù)計(jì)算
			child = parent * 2 + 1;//默認(rèn)還是計(jì)算左孩子
		}
		else
		{
			break;
		}
	}
}
void HeapPush(HP* php, HPDataType x)
{
	assert(php);
 
	if (php->size == php->capacity)//滿了，需要擴(kuò)容
	{
		size_t newCapacity = php->capacity == 0 ? 4 : php->capacity * 2;
		//翻譯：新定義一個(gè)無(wú)符號(hào)的newCapacity = 原來(lái)的capacity，如果原來(lái)的capacity = 0, 就賦值為4，4不夠就再*二倍
		HPDataType* tmp = realloc(php->a, sizeof(HPDataType)* newCapacity);
		if (tmp == NULL)
		{
			printf("reallpc failed\n");
			exit(-1); 
		}
		php->a = tmp;
		php->capacity = newCapacity;
	}
	//尾插
	php->a[php->size] = x;
	++php->size;
	//向上調(diào)整保持是一個(gè)小堆
	Adjustup(php->a, php->size - 1);
}
void HeapPop(HP* php)
{
	assert(php);
	assert(php->size > 0);
	Swap(&php->a[0], &php->a[php->size - 1]);
	--php->size;
	AdjustDown(php->a, php->size, 0);
}
bool HeapEmpty(HP* php)
{
	assert(php);
	return php->size == 0;
}
size_t HeapSize(HP* php)
{
	return php->size;
}
HPDataType HeapTop(HP* php)
{
	return php->a[0];
}

void AdjustDown(HPDataType* a, size_t size, size_t root)
{
       size_t parent = root;
       size_t child = parent * 2 + 1;//默認(rèn)是左孩子
       while (child < size)
       {
              //1、選出左右孩子中小的那個(gè)，而且保證不會(huì)越界訪問(wèn)
              if (child + 1 < size && a[child + 1] <a[child])//建大堆時(shí)< 改 >
              {
                      ++child;//左孩子變?yōu)橛液⒆?
              }
              if (a[child] < a[parent])//建大堆時(shí)< 改 >
              {
                      Swap(&a[child], &a[parent]);
                      parent = child;//繼續(xù)計(jì)算
                      child = parent * 2 + 1;//默認(rèn)還是計(jì)算左孩子
              }
              else
              {
                      break;
              }
       }
}
void HeapSort2(int* a, int n)
{
	//向上調(diào)整--建堆
	//for (int i = 1; i < n; ++i)
	//{
	//	AdjustUp(a, i);
	//}
	//向下調(diào)整--建堆O（N）
	for (int i = (n - 1 - 1) / 2; i >= 0; --i)
	{
		AdjustDown(a, n, i);//為什么向下調(diào)整要多傳一個(gè)參數(shù)，因?yàn)楫?dāng)child>=size 時(shí)說(shuō)明已經(jīng)到了邊界
	}
	size_t end = n - 1;//n - 1是最后一個(gè)數(shù)據(jù)的下標(biāo)
	while (end > 0)
	{
		Swap(&a[0], &a[end]);
		AdjustDown(a, end, 0);
		//次大的數(shù)到了倒數(shù)第二個(gè)位置
		--end;
	}
}
int main()
{
//	TestHeap();
	int a[] = { 4 , 2, 7, 8, 5, 1, 0, 6 };
	HeapSort(a, sizeof(a) / sizeof(int));
	for (int i = 0; i < sizeof(a) / sizeof(int); i++)
	{
		printf("%d ", a[i]);
	}
	printf("\n");
	return 0;
}

void PrintTopk(int* a, int n, int k)
{
	//1、建堆-- 用a中前k個(gè)元素建堆
	int* kminHeap = (int*)malloc(sizeof(int)* k);
	assert(kminHeap);
	//2、將剩余n-k元素依次與堆頂元素交換，不滿則替換
	for (int i = 0; i < k; i++)
	{
		kminHeap[i] = a[i];//將前k個(gè)數(shù)給給它
	}
	//第k-1個(gè)是最后一位數(shù)的下標(biāo)，(k - 1 -1) / 2是倒數(shù)第一個(gè)非葉子結(jié)點(diǎn)
	//建小堆
	for (int j = (k - 1 - 1) / 2; j >= 0; --j)
	{
		AdjustDown(kminHeap, k, j);
	}
	//2、將剩余n - k元素依次與堆頂元素交換，不滿則替換
	for (int i = k; i < n; ++i)
	{
		if (a[i] > kminHeap[0])
		{
			kminHeap[0] = a[i];
			AdjustDown(kminHeap, k, 0);//從根這個(gè)點(diǎn)向下調(diào)
		}
	}
	for (int j = 0; j < k; j++)
	{
		printf("%d ", kminHeap[j]);
	}
	printf("\n");
	free(kminHeap);
}
void TestTopk()
{
	int n = 10000;
	int* a = (int*)malloc(sizeof(int)* n);
	srand(time(0));
	for (size_t i = 0; i < n; ++i)
	{
		a[i] = rand() % 1000000;
	}
	a[5] = 1000000 + 1;
	a[1231] = 1000000 + 2;
	a[531] = 1000000 + 3;
	a[5121] = 1000000 + 4;
	a[115] = 1000000 + 5;
	a[2305] = 1000000 + 6;
	a[99] = 1000000 + 7;
	a[76] = 1000000 + 8;
	a[423] = 1000000 + 9;
	a[0] = 1000000 + 1000;
	PrintTopk(a, n, 10);
}
int main()
{
	TestTopk();
	return 0;
}