数据结构【堆的实现、堆排序、TopK问题--7】

目录

1.1 堆的概念

1.2 堆的性质

1.3 堆的定义

1.4 堆的向上调整

1.5 堆的向下调整

1.6 堆的创建

1.7 堆的插入

1.8 堆的删除（堆顶数据）

2.1 堆排序

2.2 建堆时间复杂度

3.1 TopK问题

4.原码链接

 

---

1.1 堆的概念

堆(Heap)是计算机科学中一类特殊的数据结构的统称。堆通常是一个可以被看做一棵完全二叉树的数组对象。

如果有一个关键码的集合K = {k0，k1， k2，…，kn-1}，把它的所有元素按完全二叉树的顺序存储方式存储在一个一维数组中，并满足：Ki <= K2i+1 且 Ki<= K2i+2 (Ki >= K2i+1 且 Ki >= K2i+2) i = 0，1，2…，则称为小堆(或大堆)。将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。
 

---

1.2 堆的性质

1.堆总是一棵完全二叉树。

2.堆中某个节点的值总是不大于或不小于其父节点的值；

3.树中所有的父亲都是小于等于孩子称为小根堆；树中所有的父亲都是大于等于孩子称为大根堆；

---

1.3 堆的定义

普通的二叉树是不适合用数组来存储的，因为可能会存在大量的空间浪费。而完全二叉树更适合使用顺序结构存储。现实中我们通常把堆(一种二叉树)使用顺序结构的数组来存储

typedef int HPDataType;
typedef struct Heap
{
	HPDataType* a;
	int size;
	int capacity;
}HP;

---

1.4 堆的向上调整

插入数据入堆后应该继续保持堆的性质，这里以小根堆举例

从最后一个节点开始，与它的父节点进行判断，如果比父节点小，则与父节点交换。当在尾部插入元素14时，14比祖先小不符合堆性质，如果想插入后还是堆，我们应该调整插入位置的祖先：28，18，15

​

​

​

​ 注意事项：

1.如果判断条件为父亲>=0，父亲到0时，-1/2还是0，父亲永远>=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 (child>0)//如果判断条件为父亲=0，父亲到0时，-1/2还是0，父亲永远>=0
	{
		if (a[child] < a[parent])
		{
			Swap(&a[child], &a[parent]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

---

1.5 堆的向下调整

int arr[10] = {27, 15, 19, 18, 28, 34, 65, 49, 25, 37};

给出一个数组，首先将它化成完全二叉树的样子 

​

如果我们要将它化为一个小堆就需要用到向下调整算法

首先让27 与 15交换

​

27与18交换 

​

 27与25交换

​

我们就构建出了一个小堆。

因为小堆的特性是所有的父节点都需要比他的子节点小，所以我们就可以通过判断，当存在子节点比父节点小的时候，让最小的子节点与父节点进行交换

---

向下调整删除元素

小根堆举例，当删除元素后，如果想继续保持堆的结构，可以让最后一个叶结点和第一个根节点互换，保持左子树和右子树继续维持小堆关系

​

交换后，删除15这个叶结点

​ 第一个祖先节点找到左右节点中小的结点，交换

​ 依次执行下去，删除数据后还是一个堆

 ​

​

void AdjustDown(HPDataType*a,int sz,int parent)//parent是开始调整的位置
{
	int child = (parent * 2) + 1;//默认小的为左孩子
	while (child < sz)
	{
		//if (child+1 < sz && a[child+1] < a[child])//如果child+1小于sz，证明没有右孩子(小堆);如果右孩子<左孩子则到右边
		if (child+1 < sz && a[child+1] > a[child])//(大堆)
		{
			++child;
		}
		//if (a[child] < a[parent])(小堆)
		if (a[child] > a[parent])//(大堆)
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break; 
		}
	}
}

---

1.6 堆的创建

 

void HeapPush(HP* php, HPDataType x)
{
	assert(php);
	if (php->capacity == php->size)
	{
		int newcapacity = php->capacity == 0 ? 4 : php->capacity * 2;
		HPDataType* tmp = (HPDataType*)realloc(php->a, sizeof(HPDataType)*newcapacity);
		if (tmp == NULL)
		{ 
			printf("realloc fail");
			exit(-1);
		}
		php->capacity = newcapacity;
		php->a = tmp;
	}
	php->a[php->size] = x;
	php->size++;

	AdjustUp(php->a, php->size - 1);//从下往上进行调整，保持堆的结构不变
}

void HeapTest()
{
	HP hp;
	HeapInit(&hp);
	int a[] = { 27,15,19,18,28,34,65,49,25,37 };
	for (int i = 0; i < sizeof(a) / sizeof(a[0]); i++)//向上调整的过程就是在建堆
	{
		HeapPush(&hp, a[i]);
	}
}

 

1.7 堆的插入

为什么我们有了向下调整算法还需要用到向上调整算法呢？

因为当我们在堆尾插入数据后，我们还需要将插入后的堆调整为小根堆的情况，但是如果这个时候我们直接使用一次向下调整算法，不仅不能将数组调整为小根堆，还会将数据打乱，毁坏他们原本的关系。就算按照建立初始堆的方法使用向下调整算法，效率也是极为的底下。而在这个位置我们直接从插入的开始使用向上调整算法，就可以最快的使这个插入点到达他应该到的位置，这样的效率也是最高的

其中每次插入后不断从下往上调整，保持堆结构不变

void HeapPush(HP* php, HPDataType x)
{
	assert(php);
	if (php->capacity == php->size)
	{
		int newcapacity = php->capacity == 0 ? 4 : php->capacity * 2;
		HPDataType* tmp = (HPDataType*)realloc(php->a, sizeof(HPDataType)*newcapacity);
		if (tmp == NULL)
		{ 
			printf("realloc fail");
			exit(-1);
		}
		php->capacity = newcapacity;
		php->a = tmp;
	}
	php->a[php->size] = x;
	php->size++;

	AdjustUp(php->a, php->size - 1);//从下往上进行调整，保持堆的结构不变
}

---

1.8 堆的删除（堆顶数据）

注意事项：

1.删除时，如果直接删除堆顶元素会破坏堆结构，我们采用交换第一个祖先结点和最后一个叶结点，交换后删除，由于最后一个节点容易删除，只需要size--即可

2.再对堆进行一次向下调整算法，就可以实现。因为堆的结构并没有被改变，唯一的变化就是堆首换成了原来的堆尾，这样只需要一趟的向下调整算法就可以实现

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);//从根开始调整
}

 

---

2.1 堆排序

​

堆排序

排升序，就要建立大根堆，如果排降序，就要建立小根堆。

给一个数组如何把数组变成堆，这里有两种思路：

1.向上调整建堆思路：

让第0个位置默认为堆元素，从数组下标为1的位置向上调整（变相插入操作），每次插入就是一个向上调整的过程，一直调整到最后一个

	//建堆方式1：向上调整，时间复杂度为O(N*logN)
for (int i = 1; i < n; ++i)
	{
		Adjustup(a, i);
	}

 

 

2.向下调整建堆思路：

向下调整算法有一个前提：左右子树必须是一个堆
如果要调整一个完全二叉树为初始堆，就必须保证所有的节点的左右子树都满足这一个前提，所以我们需要从最后一个节点的父节点开始，倒着进行向下调整算法，这样就可以保证前提的实现，创建初始堆（但是一趟的向下调整算法并不能完成堆的创建）

左右子树都不是堆情况下，叶子结点不需要调整（调整无意义，叶子节点无左右孩子，向下调整中child永远<size），直到找到倒数第一个非叶子结点，直到调到第一个根，建堆完成

倒数第一个非叶子结点下标是n-1 -1/2是算出父亲下标，依次调堆即可

	//建堆方式2：向下调整,有前提：左右子树必须是堆,时间复杂度为O(N)，升序建大堆，降序建小堆（相反）
	for (int i = (n-1-1)/2; i >=0; --i)//n-1是下标，再-1/2是父亲下标位置：没有条件创造条件成堆
	{
		AdjustDown(a, n,i);
	}

注意：调整时位置看作根 左子树 右子树调整

​

开始调整第一个子树

​

 调整第二个子树，找到左右子树中大的，调整左右子树中较大的数

​

继续找左右子树中较大的，调整

​

这时候再去调整15，15的左右子树满足大堆，向下调整

​

最后再调整第一个节点，此时第一个节点左右子树都满足大根堆

---

当建小堆时，我们把最小的数据放到第0个位置，剩余的数18~37应该建成一个堆，关系全乱需要重新建堆，选出一个小的数，再建堆再次选出次小的不断重复，代价巨大，时间复杂度为O(N^2)

​

用大根堆，堆顶是最大的数据，我们把他和末尾数字交换（按照堆删除思路走），我们就把最大的数据放到最后了，保持左右子树还是堆，再向下调整建堆，按照这种方法一次将次大数据放到末尾，就完成了排序

​

这就是堆排序的核心，也就是选择排序的思路，每趟选择一个最大或者最小的元素放到它应该呆的位置上。

同时，使用大根堆还有一个优势，就是交换后堆的结构没有被破坏，只需要一趟向下排序算法就可以再次建立大根堆，这样的效率是非常高的。

如何排序？

把排好序的最好数不当成堆中元素，原来堆有n个数，变成n-1个元素，优势是左右子树还是保持堆的结构（堆删除思路），此时向下调整一次即可选出较大的数，再把次大的数放到倒数第二个，不把他看成堆中元素，再次调整......最后一个数为堆中最大的数，倒数第二个数为剩余堆中最大的数据，依次到最后便是有序数组

总共要选出N个数，选第一个数为N，后面每个数为logN，有N-1个数要选，总时间复杂度为O(N*logN)

​

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

void AdjustDown(HPDataType*a,int sz,int parent)
{
	int child = (parent * 2) + 1;//默认小的为左孩子
	while (child < sz)
	{
		if (child+1 < sz && a[child+1] > a[child])//如果child+1小于sz，证明没有右孩子
		{
			++child;
		}
		if (a[child] > a[parent])
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break; 
		}
	}
}

void HeapSort(int *a,int n)
{
	//建堆方式1：向上调整，时间复杂度为O(N*logN)
	//for (int i = 1; i < n; ++i)
	//{
	//	Adjustup(a, i);
	//}
	//建堆方式2：向下调整,有前提：左右子树必须是堆,时间复杂度为O(N)，升序建大堆，降序建小堆（相反）
	for (int i = (n-1-1)/2; i >=0; --i)//n-1是下标，再-1/2是父亲下标位置：没有条件创造条件成堆
	{
		AdjustDown(a, n,i);
	}
	int end = n - 1;
	while (end >0)
	{
		Swap(&a[0], &a[end]);//把最大的数换到最后位置
		AdjustDown(a,end,0);//向下调整选出次大的数，不能再把原先最大的数看作堆里数据,从0开始调
		--end;
	}
}

int main()
{
	int a[] = { 27,15,19,18,28,34,65,49,25,37 };
	HeapSort(a, sizeof(a) / sizeof(a[0]));
	for (int i = 0; i < sizeof(a) / sizeof(a[0]); i++)
	{
		printf("%d ", a[i]);
	}
	return 0;
}

---

2.2 建堆时间复杂度

​

向下调整建堆时，第一层最多向下调整h-1次（从倒数第一个非叶子结点开始调整，最后一层不需要调整）。倒数第一层结点多调的次数少，第一层结点少调整次数多。

总共调整次数为T(N)= 2^0*(h-1) +2^1 *(h-2)+...+2^(h-3)*2+2^(h-2)*1   （红色代表每层结点个数，黑色代表每层最坏调整次数）

归纳公式（等比值*等差值，调整用错位相减法，左右两边同时X2，公式1第一项留下，公式2最后一项留下，其余项相减）

T（N）= 2^0*(h-1) +2^1 *(h-2)+...+2^(h-3)*2+2^(h-2)*1  

2*T（N）= 2^1*(h-1) +2^2 *(h-2)+...+2^(h-2)*2+2^(h-1)*1

​

​

​

---

向上调整时间复杂度

向上调整是从第二层开始调整，一直调整到最后一层，向上调整不算第一层

向下调整从倒数第二层开始调，一直调整到第一层。向下调整不算最后一层

但是向上调整最后一层至少占一半的结点

​

T(N) =2^1 *1 + 2^2 *2 +2^3 *3... + 2^(h-2) *(h-2 )+2^(h-1) *(h-1)  （红色代表每层结点个数，黑色代表每层最坏调整次数）

2T(N) =2^2 *1 + 2^3 *2 +2^4 *3... + 2^(h-1) *(h-2 )+2^(h) *(h-1) 

​

借一个1，再加上一个1，前面部分利用等比公式算出结果为 -（2^h -1）​

所以：T(N)= -(2^h -1） +2^h*(h-1) +1

由于2^h-1 = N,换算得出  T(N) = -N + (N+1) (log2(N+1)-1)+ 1

所以向上建堆时间复杂度为O(N*logN)

注意：为什么要算总次数：N是整棵树节点数量，建堆调整跟节点数量N有关，建堆时间复杂度需要往树的结点去换算，T（N）是总调整次数（归纳公式），每个节点*最多最坏调整次数 最终换算下来是跟h（深度）有关的公式，利用结点总数是2^(h)-1 = N 得出时间复杂度（最开始换算成N不好换算）

---

3.1 TopK问题

TOP-K问题：即求数据结合中前K个最大的元素或者最小的元素（N个数中找出最大/最小的前K个，一般N远大于K），一般情况下数据量都比较大。

实际应用场景：专业前10名、世界500强.....

​

N个数中找最大前K个数思路：

1.对于Top-K问题，能想到的最简单直接的方式就是排序O(N*logN)，但是如果数据量非常大，排序就不太可取了(可能数据都不能一下子全部加载到内存中)。

2.建立N个数的大堆，Top/Pop K次 ，时间复杂度为O(N+logN*K),问题是空间复杂度为O(N)，假设N为100亿，K为100，换算下来数据量有40G，内存空间通常存不下，建不了堆也不好排序

3.建立K个数的堆，求前k个最大的元素，则建小堆。求前k个最小的元素，则建大堆。

前K个数建立小堆，剩下N-K个数依次跟堆顶数据比较，如果比堆顶大，则替换堆顶数据进堆，最后堆中数据便是最大的前K个。

建立大堆还是小堆？

如果建立大堆，只能选出K中·最大的一个数，最大的数在堆顶，剩下的元素都进不了堆。

为什么要建小堆？

建小堆时，如果来的是最大的前K个，一定比堆顶数据大，可以进堆。

有没有可能来了个第90大的数进堆，此时再来个第96大的数进不了堆的问题呢？不会，因为这是小堆，大的数已经沉到下面去了，最后只有第100个大的才能到堆顶，其他数进不了堆。当第100大数没来时，一定是比100小的数在堆顶

时间/空间复杂度？

这个写法的时间复杂度为O(K+(N-K)*logK) --有N-K个数进行比较，其中最坏情况下每次数都比堆顶数大，每次调整进堆        

时间复杂度没有提升多少，但是空间复杂度为O(K)

void AdjustDown(HPDataType*a,int sz,int parent)//parent是开始调整的位置
{
	int child = (parent * 2) + 1;//默认小的为左孩子
	while (child < sz)
	{
		if (child+1 < sz && a[child+1] < a[child])//如果child+1小于sz，证明没有右孩子(小堆)；如果右孩子<左孩子则到右边
		//if (child+1 < sz && a[child+1] > a[child])//(大堆)
		{
			++child;
		}
		if (a[child] < a[parent])//(小堆)
		//if (a[child] > a[parent])//(大堆)
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break; 
		}
	}
}

void PrintTopK(int* a, int n, int k)
{
	// 1. 建堆--用a中前k个元素建堆
	int* kMinHeap = (int*)malloc(sizeof(int) * k);
	assert(kMinHeap);
	for (int i = 0; i < k; ++i)//把前k个数放进去
	{
		kMinHeap[i] = a[i];
	}

	for (int i = (k - 1 - 1) / 2; i >= 0; --i)//k-1是下标，-1/2是父亲公式
	{
		AdjustDown(kMinHeap, k, i);//向下调整建成堆
	}
	// 2. 将剩余n-k个元素依次与堆顶元素交换，不满则则替换
	for (int j = k; j < n; ++j)//剩余N-K个元素与堆第一个元素比较，如果比堆顶元素大则交换
	{
		if (kMinHeap[0] < a[j])
		{
			kMinHeap[0] = a[j];
			AdjustDown(kMinHeap,k,0);//再次向下调整堆
		}
	}
	for (int i = 0; i < k; ++i)
	{
		printf("%d ", kMinHeap[i]);
	}
}

void TestTopk()
{
	int n = 10000;
	int* a = (int*)malloc(sizeof(int) * n);
	assert(a);
	srand(time(0));
	for (int 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[2335] = 1000000 + 6;
	a[9999] = 1000000 + 7;
	a[76] = 1000000 + 8;
	a[423] = 1000000 + 9;
	a[3144] = 1000000 + 10;
	PrintTopK(a, n, 10);
}

---

4.原码链接

- 每日刷题: 刷题 - Gitee.com