堆的TopK问题，优先级序列，堆排序d

堆的概念：

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

    小堆(大堆)中：任一结点的关键码均小于(大于)等于它的左右孩子的关键 码，位于堆顶结点的关键码最小(最大)，从根节点到每个结点的路径上数 组元素组成的序列都是递增(递减)的堆存储在下标为0开始的数组中，因此在堆中给定下标为i的结点时

        如果i=0，结点i是根节点，没有双亲节点；否则结点i的双亲结点为 结点(i-1)/2 
        如果2 * i + 1 <= n - 1，则结点i的左孩子为结点2 * i + 1，否则结 点i无左孩子 

        如果2 * i + 2 <= n - 1，则结点i的右孩子为结点2 * i + 2，否则结 点i无右孩子

堆的创建：

void MakeHeap(Datatype *a,size_t n)
{
	int i=(n-2)/2;//最后一个节点的父亲
	for (;i>=0;i--)
	{
		AdjustDownS(a,n,i);//向下调整
	}
}
void AdjustDownS(Datatype *a,size_t n,int k)//小堆
{
	int parent=k;
	int child=parent*2+1;
	while (child<n)
	{
		if (a[child+1]<a[child] && child+1<n)//俩个孩子选大的
		{
			++child;
		}
		if (a[parent]>a[child])//若父亲大于儿子则交换值
		{
			Datatype tmp=a[parent];
			a[parent]=a[child];
			a[child]=tmp;

			parent=child;//
			child=parent*2+1;用依次调整
		}
		else
		{
			break;
		}
	}
}

TopK问题：

首先构建TopK函数：查找最大的前K项 需建立小堆 反之大堆

void TopK(Datatype* a, size_t n, size_t k)//找出最大的前K项
{
	int j;
	int i=(n-2)/2;
	for (;i>=0;i--)//找最大的前K项 需要创建小堆
	{
		AdjustDownS(a,n,i);
	}
	for (j=k;j<n;j++)//从K后进行比较
	{
		if (a[0]<a[j])//大的进行值替换
		{
			a[0]=a[j];
			AdjustDownS(a,k,0);//小堆调整
		}
	}
	for (j=1;j<=k;j++)
	{
		printf("%d ",a[j-1]);//打印最大的前K项
	}
}

TopK问题测试用例：

void Test1()
{
	int i;
	Datatype a[]={10,11, 13, 12, 16, 18, 15, 17, 14, 19};
	Datatype NArray[1000]; 
	srand(time(0)); 
	for (i = 0; i < 1000; ++i) 
	{ 
		NArray[i] = rand()%10000; 
	} 

	NArray[30] = 10001; 
	NArray[350] = 10002; 
	NArray[999] = 10003; 
	NArray[158] = 10004; 
	NArray[334] = 10005; 

	TopK(NArray, 1000, 5); 
	
	//MakeHeap(a,sizeof(a)/sizeof(a[0]));
}

优先级序列问题：

首先创建结构体：

typedef int Datatype;
typedef struct PriorityQueue
{
	Datatype _a[N];
	size_t _size;
}PriorityQueue;

在一个有序的堆里插入一个数 应用向上调整：

void AdjustUp(Datatype *a,int child)//大堆
{
	int parent=(child-1)/2;
	while (parent>=0)
	{
		if (a[parent]<a[child])
		{
			Datatype tmp=a[parent];
			a[parent]=a[child];
			a[child]=tmp;

			child=parent;
			parent=(child-1)/2;
		}
		else
		{
			break;
		}
	}
}

然后是优先级的各种的函数构造：

void PriorityQueueInit(PriorityQueue* q)//优先级初始化
{
	assert(q);
	memset(q->_a,0,sizeof(Datatype));
	q->_size=0;
	
}
void PriorityQueuePush(PriorityQueue* q, Datatype x)//在一个有序的堆里插入
{
	assert(q);
	if (q->_size==N)
	{
		printf("Priority Queue Full!!!\n");
		return;
	}
	q->_a[q->_size]=x;
	q->_size++;
	AdjustUp(q->_a,q->_size-1);//向上调整大的往上调
}
void PriorityQueuePop(PriorityQueue* q)//出堆 最大的优先出
{
	assert(q);
	if (q->_size==0)
	{
		printf("Priority Queue Empty!!!\n");
		return;
	}
	q->_a[0]=q->_a[q->_size];
	--q->_size;
	AdjustDownD(q->_a,q->_size,0);//出后 进行大堆调整
}
Datatype PriorityQueueTop(PriorityQueue* q)
{
	assert(q);
	return q->_a[0];
}
size_t PriorityQueueSize(PriorityQueue* q)
{
	return q->_size;
}
size_t PriorityQueueEmpty(PriorityQueue* q)
{
	assert(q);
	return q->_size>0?1:0;
}

优先级测试用例：

void Test2()
{

	PriorityQueue q; 
	PriorityQueueInit(&q); 
	PriorityQueuePush(&q, 5); 
	PriorityQueuePush(&q, 2); 
	PriorityQueuePush(&q, 3); 
	PriorityQueuePush(&q, 7); 
	PriorityQueuePush(&q, 6); 
	PriorityQueuePush(&q, 1); 
	PriorityQueuePush(&q, 4); 

	while (PriorityQueueEmpty(&q) != 0) 
	{ 
		printf("%d ", PriorityQueueTop(&q)); 
		PriorityQueuePop(&q); 
	} 
	printf("\n"); 
	
}

堆排序问题：

void HeapSort(Datatype* a, size_t n)//升序 堆排序
{
	int i,j;
	int tmp;
	for (i=(n-2)/2;i>=0;i--)
	{
		AdjustDownD(a,n,i);//如果要构建升序，则需要建大堆
	}
	
	for (j=n-1;j>=0;j--)//最大的替换到后边 然后在大堆排序
	{
		tmp=a[0];
		a[0]=a[j];
		a[j]=tmp;

		AdjustDownD(a,j,0);
	}
	for (i=0;i<n;i++)
	{
		printf("%d ",a[i]);
	}
}

堆排序测试用例：

void Test3()
{
	int i;
	Datatype a[]={10,11, 13, 12, 16, 18, 15, 17, 14, 19};
	HeapSort(a,sizeof(a)/sizeof(a[0]));

}