【数据结构】堆排序和TopK问题

一、堆的相关接口的实现

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

1.堆的初始化

将结构体中的变量初始化

void HeapInit(HP* php)
{
	assert(php);
	php->a = NULL;
	php->size = php->capacity = 0;
}

2.插入

堆有大堆和小堆

• 大堆：父节点大于或者等于子节点
• 小堆：父节点小于或者等于子节点
• 我们可以发现:parent=(child-1)/2
• 左孩子：child=parent*2+1
• 右孩子：child=parent*2+2
  当我们想要插入一个结点时，这个时候可能就不能保持有序了，我们选择向上调整。

将插入的结点作为孩子去找他的父节点（利用父亲与孩子的关系），如果孩子小于父亲我们就交换（这里建小堆）。

可以看出这只是调整了一次，堆还没有完全有序，我们将现在的父亲作为孩子，继续向上调整

2.1 向上调整

由上面可知向上调整的基本步骤
代码如下

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;
		}
	}
}

2.2 插入的基本操作

除了上述说的排序，保持堆的顺序。还要考虑在插入时需不需要扩容的问题。

void HeapPush(HP* php, HPDatatype x)
{
	assert(php);
	if (php->size == php->capacity)
	{
		int newCapacity = php->capacity == 0 ? 4 : php->capacity * 2;
		HPDatatype* tem = (HPDatatype*)realloc(php->a, sizeof(HPDatatype)*newCapacity);
		if (tem == NULL)
		{
			perror("realloc fail");
			exit(-1);
		}
		php->a = tem;
		php->capacity = newCapacity;
	}
	php->a[php->size] = x;
	php->size++;
	//每push进一个数进堆，就向上调整，使加入数后仍然保持是一个堆
	AdJustUp(php->a, php->size - 1);
}

3.删除

我们不能直接删除堆顶的数据因为这样都不成堆了。
所以我们选择将对顶的数据和最后一个数交换，删除这个数，然后再调整将他调整为有序。

3.1 向下调整

这里我们用到向下调整的方法，向下调整和向上调整最大的不同是，向下调整是知道了父亲，我们找孩子去与之比较时，有两个孩子，所以先比出两个孩子中更小的那一个。

void AdJustDown(HPDatatype*a,int n,int parent)
{
	//左孩子
	int child = parent * 2 + 1;
	
	while (child<n)
	{
		//堆的特点是根节点比它的子节点都要大或小，所以这里找出子树中节点最大或者最小的
		if (child + 1 < n && a[child + 1] < a[child])
		{
			child++;
		}
		//如果child小于parent那就交换
		if (a[child] < a[parent])
		{
			swap(&a[child], &a[parent]);
			//继续往下调整，直到调整完
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

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);
}

4.建堆

可以直接插入建堆，但是这种方法效率太低了。代码如下

void HeapCreate(HP* php, HPDatatype* a, int n)
{
	assert(php);
	HeapInit(php);
	int i = 0;
	for (i = 0; i < n; i++)
	{
		HeapPush(php, a[i]);
	}
}

我们用向上调整和向下调整两种方法来建堆。

向上调整建堆（时间复杂度O（NlogN)）

• 每一个数入堆的前，这个堆已经是个大堆或者小堆。
• 从i=1开始（i=0只有一个数，默认是建好了堆的），每一个入堆时都要进行调整，保证下一个数入堆前，该堆是有序的。

向下调整建堆（时间复杂度O（N））
这里我们的思想是，将一个大堆看成许多的小堆，先调整每一个小堆，再调整大一点的堆，如此最后调整整个堆。

这里从最后一个结点找他的父亲，由公式知应该为i=(n-1-1)/2然后向下调整。i–找到了第二个小堆的父亲，继续向下调整。

void HeapCreate(HP* php, HPDatatype* a, int n)
{
	assert(php);
	php->a = (HPDatatype*)malloc(php->a, sizeof(HPDatatype) * n);
	if (php->a == NULL)
	{
		perror("realloc fail");
		exit(-1);
	}
	memcpy(php->a, a, sizeof(HPDatatype) * n);
	php->size = php->capacity = n;

	// 建堆算法
	for (int i = 1; i < n; i++)
	{
		AdJustUp(php->a, i);
	}

	/*for (int i = (n - 1 - 1) / 2; i >= 0; --i)
	{
		AdJustDown(php->a, n, i);
	}*/
}

5.堆的销毁

void HeapDestroy(HP* php)
{
	assert(php);
	free(php->a);
	php->a = NULL;
	php->size = php->capacity = 0;

}

6.取堆顶

HPDatatype HeapTop(HP* php)
{
	assert(php);
	assert(php->size > 0);
	return php->a[0];
}

7.堆的大小

int HeapSize(HP* php)
{
	assert(php);

	return php->size;
}

8.堆的判空

bool HeapEmpty(HP* php)
{
	assert(php);

	return php->size == 0;
}

二、堆排序（时间复杂度NlogN）

思想： 一个堆中有n个数，如果是排升序就建大堆，排降序就建小堆。建堆成功之后就将堆顶的数和最后一个数交换，然后将这个数排外，剩下n-1个数排序继续重复此过程。

这个思想中，建大堆还是建小堆可能会比较纠结。
我们排升序如果建小堆的话，堆顶的数肯定是最小的，但是后面呢，如果向上面一样除去这个已经排好的数，去排剩下的n-1个数，但是我们现在去除的是堆顶的数，剩下的数都不成堆了，怎么堆排序呢。

于是我们想到，如果排升序就建大堆，堆顶的数就是最大的，和最后一个数互换，除去这个最大的数，剩下的数还是成堆的，因此堆排序是从后面开始排。

void AdjustDown(int* a, int n, int parent)
{
	int child = parent * 2 + 1;
	while (child < n)
	{
		//确认child指向大的那个孩子
		if (child + 1 < n && a[child + 1] < a[child])
		{
			++child;
		}
		//1、孩子大于父亲就交换，继续向下调整
		//2、孩子小于父亲就结束
		if (a[child]<a[parent])
		{
			swap(&a[parent], &a[child]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}
void HeapSort(int* a, int n)
{
	for (int i = (n-1-1)/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个最大的数或者最小的数
这种问题我们有两种解决办法
1.每次取堆顶，向下调整，但是这种办法在数据量太大的时候，内存放不下无法进行操作。
2.先取前K个数进行建堆（这里以取出k个最大的数为例），建小堆，如果数组里第k+1个数比堆顶的数大，那么就交换。这样就可以这个k个数的小堆就是前k个最大的数。

void TopK(int* array, int n, int k)
{
	
	HP hp;
	HeapInit(&hp);
	//创建一个K个数的小堆
	for (int i = 0; i < k; i++)
	{
		HeapPush(&hp, array[i]);
	}
	for (int i = k; i < n; i++)
	{
		if (array[i] > HeapTop(&hp))
		{
			hp.a[0] = array[i];
			AdJustDown(hp.a, hp.size, 0);//向下调整
		}

	}
	HeapPrint(&hp);
	HeapDestroy(&hp);
}