1、概述
队列是一种满足先进先出（FIFO）的数据结构，数据从队列头部取出，新的数据从队列尾部插入，数据之间是平等的，不存在优先级的。这个就类似于普通老百姓到火车站排队买票，先来的先买票，每个人之间是平等的，不存在优先的权利，整个过程是固定不变的。而优先级队列可以理解为在队列的基础上给每个数据赋一个权值，代表数据的优先级。与队列类似，优先级队列也是从头部取出数据，从尾部插入数据，但是这个过程根据数据的优先级而变化的，总是优先级高的先出来，所以不一定是先进先出的。这个过就类似于买火车票时候军人比普通人优先买，虽然军人来的晚，但是军人的优先级比普通人高，总是能够先买到票。通常优先级队列用在操作系统中的多任务调度，任务优先级越高，任务优先执行（类似于出队列），后来的任务如果优先级比以前的高，则需要调整该任务到合适的位置，以便于优先执行，整个过程总是使得队列中的任务的第一任务的优先级最高。
优先级队列有两种：最大优先级队列和最小优先级队列，这两种类别分别可以用最大堆和最小堆实现。书中介绍了基于最大堆实现的最大优先级队列。一个最大优先级队列支持的操作如下操作：
INSERT(S,x)：把元素x插入到集合S
MAXIMUM(S)：返回S中具有最大关键字的元素
EXTRACT_MAX(S)：去掉并返回S中的具有最大关键字的元素
INCREASE_KEY(S,x,k)：将元素x的关键字的值增加到k，这里k值不能小于x的原关键字的值。
2、最大优先级队列操作实现
采用最大堆实现最大优先级队列，关于最大堆可以参见上一篇日志http://www.cnblogs.com/Anker/archive/2013/01/23/2873422.html。
（1）HEAP_MAXIMUM用O(1)时间实现MAXIMUM(S)操作，即返回最大堆第一个元素的值即可（return A[1])。
（2）HEAP_EXTRACT_MAX实现EXTRACT_MAX操作，删除最大堆中第一个元素，然后调整堆。操作过程如下：将最堆中最后一个元素复制到第一个位置，删除最后一个节点（将堆的大小减少1），然后从第一个节点位置开始调整堆，使得称为新的最大堆。操作过程如下图所示：
伪代码描述如下：
1 HEAD_EXTRACT_MAX(A) 2 if heap_size[A]<1 3 ther error 4 max = A[1] 5 A[1] = A[heap_size[A]]; 6 heap_size[A] = heap_size[A]-1 7 adjust_max_heap(A,1) 8 return MAX
（3）HEAP_INCREASE_KEY实现INCREASE_KEY，通过下标来标识要增加的元素的优先级key，增加元素后需要调整堆，从该节点的父节点开始自顶向上调整。操作过程如下图所示：
伪代码描述如下：
1 HEAP_INCREASE_KEY(A,i,key) 2 if key < A[i] 3 then error 4 A[i] = key 5 while i>1 && A[PARENT(i)] <A[i] 6 do exchange A[i] <-> A[PARENT(i)] 7 i = PARENT(i)
（4）MAX_HEAP_INSERT实现INSERT操作，向最大堆中插入新的关键字。新的关键字插入在优先级的队尾部，然后从尾部的父节点开始自顶向上调整堆伪代码描述如下：
1 MAX_HEAP_INSERT(A,key) 2 heap_size[A] = heap_size[A]+1 3 A[heap_size[A]] = -0; 4 HEAP_INCREASE_KEY(A,heap_size[A],key)
3、实例
问题描述如下：优先级队列中有多个事件发生，每个事件有自己独立的优先级，优先级是非负数，数值越大优先级越高。采用最大优先级队列模拟事件执行的优先顺序。具体操作包括：
（1）向优先级队列中添加一个新事件
（2）获取优先级队列中优先级最高的事件
（3）删除优先级队列中指定位置的事件
（4）增加优先级队列中指定位置事件的优先级
（5）降低优先级队列中指定位置事件的优先级
采用C++语言实现，完整程序如下所示：
View Code
1 #include <iostream> 2 #include <string> 3 #include <cstdlib> 4 using namespace std; 5 6 const static int QUEUELEN = 100; 7 8 class Event 9 { 10 public: 11 Event():eventname(""),priority(-1){}; 12 Event(const string &en,const int p):eventname(en),priority(p){}; 13 Event(const Event& en) 14 { 15 eventname = en.eventname; 16 priority = en.priority; 17 } 18 ~Event(){}; 19 int get_event_priority()const 20 { 21 return priority; 22 } 23 string get_event_name()const 24 { 25 return eventname; 26 } 27 void increase_event_priority(const int k) 28 { 29 priority = priority + k; 30 } 31 void decrease_event_priority(const int k) 32 { 33 priority = priority - k; 34 } 35 void show_event() const 36 { 37 cout<<"Eventname is: ("<<eventname<<") and the priority is: "<<priority<<endl; 38 } 39 private: 40 string eventname; 41 int priority; 42 }; 43 class PriorityQueue 44 { 45 public: 46 PriorityQueue(); 47 void adjust_event(int index); 48 Event get_event()const; 49 void insert_event(const Event& en); 50 void increase_event_priority(int pos,int k); 51 Event delete_event(int pos); 52 void show_events() const; 53 ~PriorityQueue(); 54 private: 55 Event *events; 56 int length; 57 }; 58 59 PriorityQueue::PriorityQueue() 60 { 61 events = new Event[QUEUELEN]; 62 length = 0; 63 } 64 65 PriorityQueue::~PriorityQueue() 66 { 67 if(!events) 68 delete [] events; 69 length = 0; 70 } 71 //adjust max heap 72 void PriorityQueue::adjust_event(int index) 73 { 74 int left,right,largest; 75 Event temp; 76 while(1) 77 { 78 left = index*2; 79 right = index*2+1; 80 if(left <= length && 81 events[left].get_event_priority() > events[index].get_event_priority()) 82 largest = left; 83 else 84 largest = index; 85 if(right <= length && 86 events[right].get_event_priority() > events[largest].get_event_priority()) 87 largest = right; 88 if(largest != index) 89 { 90 temp = events[index]; 91 events[index] = events[largest]; 92 events[largest] = temp; 93 index = largest; 94 } 95 else 96 break; 97 } 98 } 99 Event PriorityQueue::get_event()const 100 { 101 if(length != 0) 102 return events[1]; 103 else 104 return Event(); 105 } 106 107 void PriorityQueue::insert_event(const Event& en) 108 { 109 length = length + 1; 110 events[length] = en; 111 increase_event_priority(length,0); 112 } 113 114 void PriorityQueue::increase_event_priority(int pos,int k) 115 { 116 int i,parent; 117 Event temp; 118 if(pos > length) 119 { 120 cout<<"error: the pos index is larger than queue length"<<endl; 121 return; 122 } 123 events[pos].increase_event_priority(k); 124 i = pos; 125 parent = i/2; 126 while(i>1 127 && events[parent].get_event_priority() < events[i].get_event_priority()) 128 { 129 temp = events[i]; 130 events[i] = events[parent]; 131 events[parent] = temp; 132 i = parent; 133 parent = i/2; 134 } 135 } 136 137 Event PriorityQueue::delete_event(int pos) 138 { 139 Event reten; 140 if(pos > length) 141 { 142 cout<<"Error:pos index is larger than queue length"<<endl; 143 return reten; 144 } 145 reten = events[pos]; 146 events[pos] = events[length]; 147 length--; 148 adjust_event(pos); 149 return reten; 150 } 151 void PriorityQueue::show_events() const 152 { 153 if(length == 0) 154 { 155 cout<<"There is no any event in the priority queue"<<endl; 156 } 157 else 158 { 159 cout<<"There are "<<length<<" events in the priority queue."<<endl; 160 for(int i=1;i<=length;i++) 161 { 162 events[i].show_event(); 163 } 164 } 165 166 } 167 int main() 168 { 169 PriorityQueue pqueue; 170 Event en; 171 Event en1("fork",2); 172 Event en2("exec",3); 173 Event en3("wait",1); 174 Event en4("signal",6); 175 Event en5("pthread_create",5); 176 pqueue.insert_event(en1); 177 pqueue.insert_event(en2); 178 pqueue.insert_event(en3); 179 pqueue.insert_event(en4); 180 pqueue.insert_event(en5); 181 pqueue.show_events(); 182 cout<<"\nThe max priority event is: "<<endl; 183 en = pqueue.get_event(); 184 en.show_event(); 185 cout<<"\nIncrese event3 by 7"<<endl; 186 pqueue.increase_event_priority(3,7); 187 en = pqueue.get_event(); 188 en.show_event(); 189 pqueue.show_events(); 190 cout<<"\nDelete the first event:"<<endl; 191 pqueue.delete_event(1); 192 pqueue.show_events(); 193 exit(0); 194 }
程序测试结果如下所示：
4、问题
（1）如何使用优先级队列实现一个先进先出的队列和先进后出的栈？
我的想法是：队列中的元素是先进先出（FIFO）的，因此可以借助最小优先级队列实现队列。具体思想是，给队列中的每个元素赋予一个权值，权值从第一个元素到最后一个依次递增（如果采用数组实现的话，可以用元素所在的下标作为优先级，优先级小的先出队列），元素出队列操作每次取优先级队列第一个元素，取完之后需要堆最小优先级队列进行调整，使得第一个元素的优先级最小。栈中的元素与队列刚好相反，元素是先进后出（FILO），因此可以采用最大优先级队列进行实现，与用最小优先级队列实现队列思想类似，按照元素出现的顺序进行标记元素的优先级，数据越是靠后，优先级越高。
举例说明采用最小优先级队列实现先进先出队列，现在有一组数A={24,15,27,5,43,87,34}共六个数，假设数组下标从1开始，以元素所在数组中的下标为优先级创建优先级队列，队列中元素出入时候调整最小优先级队列。操作过程如下图所示：
