堆的应用之堆排序和 TOP-K问题

堆排序

        堆排序即利用堆的思想来进行排序；分为两个步骤：

1.建堆

        需要注意一般：         升序：建大堆             降序：建小堆

建堆有两种算法分别是：向上调整算法，向下调整树算法；

向上调整建堆：（以建大堆为例）

//对数据向上调整：
void adjustup(heapdatesype* p, int child)
{
	int parent = (child - 1) / 2;
	while (child > 0)
	{
		if (p[parent] < p[child])
		{
			swap(&(p[parent]), &(p[child]));
			child = parent;
			parent = (parent - 1) / 2;
		}
		else
		{
			break;
		}
	}
	
}


//向上调整：
	for (int i = 1; i < n; i++)
	{
		adjustup(a, i);
	}

1.关于adjustup 函数的实现可以参见我的上篇博客《C语言实现堆》

2.向上调整需要的条件是前面的数据为一个堆，因此从i=1（i=0一个数据已经可以认为是一个堆）

开始从前往后对每一个数据进行调整建堆；

3.向上调整建堆的时间复杂度：可以利用错位相减法计算出：n*(log以2为底n的对数)；其中n为数据个数；

向下调整建堆：（以建大堆为例）

//堆（大堆）元素的向下调整：
void adjustdown(heapdatesype* p, int n, int parent)
{
	int child = 2 * parent + 1;
	while (child < n)
	{
		//找出更大的那个孩子：(需要保证child+1 < n)
		if ( child+1 < n && p[child] < p[child + 1])
		{
			child++;
		}
		if (p[parent] < p[child])
		{
			swap(&(p[child]), &(parent));
			//往下再次调整：
			parent = child;
			child = 2 * child + 1;
		}
		else
		{
			break;
		}
	}
}


for (int i = (n-1-1); i >=0; i--)
	{
		adjustdown(a, n, i);
	}

1.关于adjustdown 函数的实现可以参见我的上篇博客《C语言实现堆》 ;

2.向下调整建堆需要的条件是左右子树均为堆，因此从i=n-2（n-1是最后一个数据的下标，n-2则是因为最后一个元素自己已经可以被看做一个堆）开始从后往前对每个元素进行调整；

3.向下调整建堆的时间复杂度：可以利用错位相减法计算出：n   ;（其中n为数据个数）；

4.由于向下调整建堆的时间复杂度更优，堆排序则使用向下调整建堆；

2. 利用堆删除思想来进行排序

                交换堆顶元素和最后一个元素（此时最后一个元素位置已经确定），然后对堆顶元素进行向下调整；循环上述步骤；

    int end = n - 1;
	while (end > 0)
	{
		swap(&(a[end]), &(a[0]));
		adjustdown(a, end, 0);
		end--;

	}

总结：

	//堆排序  排升序建大堆；  排降序建小堆；
void HeapSort(int* a, int n)
{
	//建立大堆 or 小堆：
	//此处建了大堆：
	
	向上调整：
	//for (int i = 1; i < n; i++)
	//{
	//	adjustup(a, i);
	//}

	//向下调整：
	//时间复杂度更占优势：
	for (int i = (n-1-1); i >=0; i--)
	{
		adjustdown(a, n, i);
	}

	// 利用堆删除思想来进行排序：
	int end = n - 1;
	while (end > 0)
	{
		swap(&(a[end]), &(a[0]));
		adjustdown(a, end, 0);
		end--;

	}
}

        堆排序的时间复杂度是n*（log以2为底n的对数）； 

TOP-K问题

        TOP-K问题：即求数据中前K个最大的元素或者最小的元素，一般情况下数据量都比较大。

最佳的方式就是用堆来解决，基本思路如下：

                                1. 用数据集合中前K个元素来建堆

                                        前k个最大的元素，则建小堆

                                        前k个最小的元素，则建大堆

                                2. 用剩余的N-K个元素依次与堆顶元素来比较，不满足则替换堆顶元素

//堆（大堆）元素的向下调整：
void adjustdown(heapdatesype* p, int n, int parent)
{
	int child = 2 * parent + 1;
	while (child < n)
	{
		//找出更大的那个孩子：(需要保证child+1 < n)
		if ( child+1 < n && p[child] < p[child + 1])
		{
			child++;
		}
		if (p[parent] < p[child])
		{
			swap(&(p[child]), &(parent));
			//往下再次调整：
			parent = child;
			child = 2 * child + 1;
		}
		else
		{
			break;
		}
	}
}

int* getTopK(int* arr, int arrsize,int k,int *returnsize)
{
	*returnsize = k;
	if (k == 0)
	{
		return NULL;
	}

	//开辟有k个元素的数组空间：
	int* topk = (int*)malloc(sizeof(int) * k);

	// 用数据集合中前K个元素来建堆（大堆）
	int i = 0;
	for (i = 0; i < k; i++)
	{
		topk[i] = arr[i];
	}
	for (i = k - 1 - 1; i >= k; i--)
	{
		adjustdown(topk, k, i);
	}

	// 用剩余的N-K个元素依次与堆顶元素来比较，不满足则替换堆顶元素
	for (i = k; i < arrsize; i++)
	{
		if (arr[i] < topk[0])
		{
			topk[0] = arr[i];
		}
		adjustdown(topk, k, 0);
	}

	return topk;


}

      总结：   空间复杂度:K;            时间复杂度：K+N*(log以2为底K的对数)；