优先队列

优先队列。

为什么不从表、栈、队列这种最简单的结构开始呢？我觉得没必要，自己看没必要，别人更没必要。

优先队列，即在普通队列的 ADT 上加了一重逻辑，让符合某种条件的元素优先出队。一般以数值大小为条件，所以也分为最大化优先队列和最小化优先队列。

优先队列的核心实现是一个堆。

堆是一种特殊的数据结构。它是一棵二叉树，元素必须从左至右填入最后一层，然后再创建新一层。因此堆满足很多有趣的性质：

1）若堆的元素个数为 N，则高度不超过 [log N] + 1。

2）优先队列可以用数组表示。在这种情况下，节点 N 的父节点在 N/2 处，左子节点在 N*2 处，右子节点在 N*2+1 处。

这两条性质是优先队列高效 ADT 实现的基础。

优先队列在堆的基础上规定：父节点不能大于、或小于子节点——这取决于是最大化堆、还是最小化堆。

优先队列的思想其实也很简单。首先构造一个堆（这个不用解释了吧）。
// 预定义常量 const int minInt32 = INT_MIN; // 结构体定义 struct PriorityQueue { int maxSize; int size; int *data; }; // 创建优先队列。 PriorityQueue BuildPriorityQueue(int maxSize) { PriorityQueue ret; ret.data = (int*)malloc(sizeof(int) * (maxSize + 1)); memset(ret.data, 0, sizeof(int) * (maxSize+1)); ret.data[0] = minInt32; ret.maxSize = maxSize; ret.size = 0; return ret; } void FreePriorityQueue(PriorityQueue &Q) { free(Q.data); } 我做的是最小化堆，并在 Q.data[0] 处做了一个哑元。这样的好处之一是完全符合 N、N/2、N*2、N*2+1 的序号规则（试想一下 0/2、0*2、0*2+1 …… 寒毛耸立）。其二是入队的工作非常方便。

入队的主要思想是“上滤”。何为上滤？看看下面一个优先队列：

4
-5
--7
--10
-6
可以看得出来这个堆是符合优先队列的 ADT 的。现在为了插入元素 3，我们必须在数组最后的一项创建一个空穴。

4
-5
--7
--10
-6
--[3]
这个 3 的引入彻底破坏了 ADT。为了让 3 符合规则，这一步，我们需要将它与 6 交换位置。

4
-5
--7
--10
-[3]
--6
依旧不符合，我们再上滤，直到根。

[3]
-5
--7
--10
-4
--6
终于符合优先队列的 ADT 了！这也是用一个哑元的用意——不用判断是否到达根，只要哑元足够小，到了根自然会停下来。

但是，有一个问题，就是重复元的问题。如果重复元比原有元上滤得多，那么将破坏队列的性质（先进先出）。于是我们在比较的时候，要特别留意。

给出我的 Enqueue 代码（没有实际测试重复元问题，只是理论上验证了先进先出的性质）。
bool Enqueue(int value, PriorityQueue &Q) { // 检查参数 if (Q.size >= Q.maxSize) return false; // 创建一个单元. Q.size++; int lastIndex = Q.size; int lastHalf = lastIndex/2; Q.data[lastIndex] = value; // 上滤 while (value < Q.data[lastHalf]) { Q.data[lastIndex] = Q.data[lastHalf]; lastIndex = lastHalf; lastHalf = lastIndex/2; } Q.data[lastIndex] = value; return true; } bool Enqueue(int value, PriorityQueue &Q) { // 检查参数 if (Q.size >= Q.maxSize) return false; // 创建一个单元. Q.size++; int lastIndex = Q.size; int lastHalf = lastIndex/2; Q.data[lastIndex] = value; // 上滤 while (value < Q.data[lastHalf]) { Q.data[lastIndex] = Q.data[lastHalf]; lastIndex = lastHalf; lastHalf = lastIndex/2; } Q.data[lastIndex] = value; return true; } 
 
时间要求高的地方可以免除检查，恩~

还有出队。出队似乎很简单，由于一切都已就绪，那么返回根元素就可以了。但这就在根元素处形成了一个空穴，必须依赖于“下滤”——与“上滤”的思想基本一致。

给出代码。
int Dequeue(PriorityQueue &Q) { // 检查参数 if (Q.size <= 0) return minInt32; // 得到最小单元 int firstItem = Q.data[1]; int lastItem = Q.data[Q.size--]; int childIndex = 1, i=0; // 下滤 for (i=1; i*2<=Q.size; i=childIndex) { childIndex = i*2; if (childIndex != Q.size && Q.data[childIndex] > Q.data[childIndex+1]) { childIndex++; } if (lastItem > Q.data[childIndex]) Q.data[i] = Q.data[childIndex]; else break; } Q.data[i] = lastItem; return firstItem; } int Dequeue(PriorityQueue &Q) { // 检查参数 if (Q.size <= 0) return minInt32; // 得到最小单元 int firstItem = Q.data[1]; int lastItem = Q.data[Q.size--]; int childIndex = 1, i=0; // 下滤 for (i=1; i*2<=Q.size; i=childIndex) { childIndex = i*2; if (childIndex != Q.size && Q.data[childIndex] > Q.data[childIndex+1]) { childIndex++; } if (lastItem > Q.data[childIndex]) Q.data[i] = Q.data[childIndex]; else break; } Q.data[i] = lastItem; return firstItem; }   
出队麻烦得多，因为没有哑元的辅助，从代码上看效率要略低于入队。

至于优先队列的 IncreaseKey 与 DecreaseKey，完全可以用上滤、下滤的思想完成，不再赘述。只是必须知道元素所在数组下标，这就丧失了优先队列 ADT 的纯洁性。
另外，Delete 操作可以先 DecreaseKey，再 Dequeue。（这个过程我没有具体实现，其实也就是上滤的操作）。

P.S. 优先队列与“堆排序”有非常深的关系。后来我尝试使用这个例程对 100000 个数据进行排序，效果还不错；当然比起快排还是嫌慢了点。

 

 

 

最后给个完整代码:

#include<cstdio> #include<cstdlib> typedef int Datatype; struct PriorityQue { int max; int n; Datatype *pq; }; typedef PriorityQue *PPriorityQue; //创建空优先队列 PPriorityQue createNullQue_heap(int m) { PPriorityQue papq; papq=(PPriorityQue)malloc(sizeof PriorityQue); if(papq==NULL) { printf("Out of space!!/n"); return NULL; } papq->pq=(Datatype *)malloc((sizeof Datatype)*m); if(papq->pq==NULL) { printf("Out of space!!/n"); free(papq); return NULL; } papq->n=0; papq->max=m; return papq; } //优先队列为空返回真 int isEmptyPriorityQue_heap(PPriorityQue papq) { return (papq->n==0); } //向优先队列插入元素x int add_heap(PPriorityQue papq,Datatype x) { if((papq->n)>=(papq->max)) { printf("Overflow!!/n"); return 0; } if(isEmptyPriorityQue_heap(papq)) { papq->pq[0]=x; ++papq->n; return 1; } for(int i=papq->n;i>0 && papq->pq[(i-1)/2]>x;i=(i-1)/2) papq->pq[i]=papq->pq[(i-1)/2]; papq->pq[i]=x; ++papq->n; return 1; } //从优先队列中删除最小元素 int sift(PPriorityQue papq,int size,int p); int removeMin_heap(PPriorityQue papq) { if(isEmptyPriorityQue_heap(papq)) { printf("It is empty!!/n"); return 0; } int p=--papq->n; papq->pq[0]=papq->pq[p]; if (sift(papq,p,0)) return 1; return 0; } //把完全二叉树从指定节点调整为堆 int sift(PPriorityQue papq,int size,int p) { Datatype temp; temp=papq->pq[p]; int i=p; int child=2*i+1; while(child<size) { if(child<size-1 && papq->pq[child]>papq->pq[child+1]) ++child; if(temp>papq->pq[child]) { papq->pq[i]=papq->pq[child]; i=child; child=2*i+1; } else break; } papq->pq[i]=temp; return 1; } int main() { PPriorityQue papq; int m=5; papq=createNullQue_heap(m); add_heap(papq,200); add_heap(papq,40); add_heap(papq,5); add_heap(papq,-1); add_heap(papq,120); for(int i=0;i<papq->n;++i) //删除元素前 printf("%d ",papq->pq[i]); printf("/n"); removeMin_heap(papq); //删除最小元素-1 for(i=0;i<papq->n;++i) printf("%d ",papq->pq[i]); //删除元素后 return 0; }