算法导论--------------优先队列的研究
2014-11-16 00:10
169 查看
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://blog.csdn.net/chenxun_2010/article/details/41131445
（1）HEAP_MAXIMUM用O(1)时间实现MAXIMUM(S)操作，即返回最大堆第一个元素的值即可（return A[1])。
（2）HEAP_EXTRACT_MAX实现EXTRACT_MAX操作，删除最大堆中第一个元素，然后调整堆。操作过程如下：将最堆中最后一个元素复制到第一个位置，删除最后一个节点（将堆的大小减少1），然后从第一个节点位置开始调整堆，使得称为新的最大堆。操作过程如下图所示：
伪代码
伪代码：
上面是别人写优先队列的理解，我觉得很好，所以窃取过来.哈哈！
下面是自己根据伪代码写的：
#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
void swap(int *x, int *y)
{
int tmp = *x;
*x = *y;
*y = tmp;
}
//建立以root为i(即根节点为i)的最大堆，利用了递归的思想防止调整之后以largest为父节点的子树不是最大堆
void max_heapify(vector<int> &a, int i, int heapsize)
{
int l = 2 * i;//取其左孩子的坐标
int r = 2 * i + 1;//取其右孩子的坐标
int largest;//临时变量，用来保存r、l、r三个节点中最大的值
if (l <= heapsize&&a[l]>a[i])
largest = l;
else
largest = i;
if (r <= heapsize&&a[r]>a[largest])
largest = r;
if (largest != i)
{
swap(&a[i], &a[largest]);
max_heapify(a, largest, heapsize);
}
}
//***********************************************
//用自底向上的方法把数组转换成最大堆
void buil_max_heap(vector<int> &a, int heapsize)
{
int i;
//从heapsize/2+1到heapsize的节点都是叶节点，所以我们可以把他们都看成是包含一个元素的最大堆了
//所以从数组1到heapsize的有叶节点的节点建立最大堆
for (i = heapsize / 2; i >= 1; i--)
{
max_heapify(a, i, heapsize);
}
}
//1.返回堆中最大关键字的元素
int heap_max_inum(vector<int> a)
{
return a[1];
}
//2.去掉堆中并反会最大关键字的元素
int heap_extract_max(vector<int> &a, int &heapsize)
{
if (heapsize < 1)
cout << "there is no data in data" << endl;
int max = a[1];
a[1] = a[heapsize];
heapsize--;
a.pop_back();
max_heapify(a, 1, heapsize);
return max;
}
//3.将第i个元素的值增加到key
void heap_increase_key(vector<int> &a, int i, int key)
{
if (key < a[i])
cout << " error: new key is smaller than current key" << endl;
int p = i / 2;
a[i] = key;
while (i>1 && a[i] > a[p])
{
swap(a[i], a[p]);
i = p;
}
}
//4.将元素插入到集合中去。
void max_heap_insert(vector<int> &a, int key, int &heapsize)
{
heapsize++;
a.push_back(INT_MIN);
//a[heapsize] = INT_MIN;//给一个最小的负数，符合调用heap_increase_key
heap_increase_key(a, heapsize, key);
}
int main()
{
vector<int> a = { 0, 12, -3, 88, 52, 6, 4, 33, 2, 100, 5 };
int heapsize = a.size()-1;
cout << heapsize << endl;
buil_max_heap(a, heapsize);
for (auto i : a)
cout << i << " ";
cout << endl;
for (int i = 0; i < 10; ++i)
{
cout << heap_extract_max(a, heapsize) << endl;
for (auto i : a)
cout << i << " ";
cout << endl;
}
cout << heapsize << endl;
heap_increase_key(a, heapsize, 11);
for (auto i : a)
cout << i << " ";
cout << endl;
max_heap_insert(a, 55, heapsize);
for (auto i : a)
cout << i << " ";
cout << endl;
}
参考资料文献：http://www.cnblogs.com/Anker/archive/2013/01/23/2873951.html
再下面是别人用c++写的：
#include <iostream>
#include <string>
#include <cstdlib>
using namespace std;
const static int QUEUELEN = 100;
class Event
{
public:
Event():eventname(""),priority(-1){};
Event(const string &en,const int p):eventname(en),priority(p){};
Event(const Event& en)
{
eventname = en.eventname;
priority = en.priority;
}
~Event(){};
int get_event_priority()const
{
return priority;
}
string get_event_name()const
{
return eventname;
}
void increase_event_priority(const int k)
{
priority = priority + k;
}
void decrease_event_priority(const int k)
{
priority = priority - k;
}
void show_event() const
{
cout<<"Eventname is: ("<<eventname<<") and the priority is: "<<priority<<endl;
}
private:
string eventname;
int priority;
};
class PriorityQueue
{
public:
PriorityQueue();
void adjust_event(int index);
Event get_event()const;
void insert_event(const Event& en);
void increase_event_priority(int pos,int k);
Event delete_event(int pos);
void show_events() const;
~PriorityQueue();
private:
Event *events;
int length;
};
PriorityQueue::PriorityQueue()
{
events = new Event[QUEUELEN];
length = 0;
}
PriorityQueue::~PriorityQueue()
{
if(!events)
delete [] events;
length = 0;
}
//adjust max heap
void PriorityQueue::adjust_event(int index)
{
int left,right,largest;
Event temp;
while(1)
{
left = index*2;
right = index*2+1;
if(left <= length &&
events[left].get_event_priority() > events[index].get_event_priority())
largest = left;
else
largest = index;
if(right <= length &&
events[right].get_event_priority() > events[largest].get_event_priority())
largest = right;
if(largest != index)
{
temp = events[index];
events[index] = events[largest];
events[largest] = temp;
index = largest;
}
else
break;
}
}
Event PriorityQueue::get_event()const
{
if(length != 0)
return events[1];
else
return Event();
}
void PriorityQueue::insert_event(const Event& en)
{
length = length + 1;
events[length] = en;
increase_event_priority(length,0);
}
void PriorityQueue::increase_event_priority(int pos,int k)
{
int i,parent;
Event temp;
if(pos > length)
{
cout<<"error: the pos index is larger than queue length"<<endl;
return;
}
events[pos].increase_event_priority(k);
i = pos;
parent = i/2;
while(i>1
&& events[parent].get_event_priority() < events[i].get_event_priority())
{
temp = events[i];
events[i] = events[parent];
events[parent] = temp;
i = parent;
parent = i/2;
}
}
Event PriorityQueue::delete_event(int pos)
{
Event reten;
if(pos > length)
{
cout<<"Error:pos index is larger than queue length"<<endl;
return reten;
}
reten = events[pos];
events[pos] = events[length];
length--;
adjust_event(pos);
return reten;
}
void PriorityQueue::show_events() const
{
if(length == 0)
{
cout<<"There is no any event in the priority queue"<<endl;
}
else
{
cout<<"There are "<<length<<" events in the priority queue."<<endl;
for(int i=1;i<=length;i++)
{
events[i].show_event();
}
}
}
int main()
{
PriorityQueue pqueue;
Event en;
Event en1("fork",2);
Event en2("exec",3);
Event en3("wait",1);
Event en4("signal",6);
Event en5("pthread_create",5);
pqueue.insert_event(en1);
pqueue.insert_event(en2);
pqueue.insert_event(en3);
pqueue.insert_event(en4);
pqueue.insert_event(en5);
pqueue.show_events();
cout<<"\nThe max priority event is: "<<endl;
en = pqueue.get_event();
en.show_event();
cout<<"\nIncrese event3 by 7"<<endl;
pqueue.increase_event_priority(3,7);
en = pqueue.get_event();
en.show_event();
pqueue.show_events();
cout<<"\nDelete the first event:"<<endl;
pqueue.delete_event(1);
pqueue.show_events();
exit(0);
}
队列是一种满足先进先出（FIFO）的数据结构，数据从队列头部取出，新的数据从队列尾部插入，数据之间是平等的，不存在优先级的。这个就类似于普通老百姓到火车站排队买票，先来的先买票，每个人之间是平等的，不存在优先的权利，整个过程是固定不变的。而优先级队列可以理解为在队列的基础上给每个数据赋一个权值，代表数据的优先级。与队列类似，优先级队列也是从头部取出数据，从尾部插入数据，但是这个过程根据数据的优先级而变化的，总是优先级高的先出来，所以不一定是先进先出的。这个过就类似于买火车票时候军人比普通人优先买，虽然军人来的晚，但是军人的优先级比普通人高，总是能够先买到票。通常优先级队列用在操作系统中的多任务调度，任务优先级越高，任务优先执行（类似于出队列），后来的任务如果优先级比以前的高，则需要调整该任务到合适的位置，以便于优先执行，整个过程总是使得队列中的任务的第一任务的优先级最高。
优先级队列有两种：最大优先级队列和最小优先级队列，这两种类别分别可以用最大堆和最小堆实现。书中介绍了基于最大堆实现的最大优先级队列。一个最大优先级队列支持的操作如下操作：
INSERT(S,x)：把元素x插入到集合S
MAXIMUM(S)：返回S中具有最大关键字的元素
EXTRACT_MAX(S)：去掉并返回S中的具有最大关键字的元素
INCREASE_KEY(S,x,k)：将元素x的关键字的值增加到k，这里k值不能小于x的原关键字的值。
2、最大优先级队列操作实现
采用最大堆实现最大优先级队列，关于最大堆可以参见上一篇日志http://blog.csdn.net/chenxun_2010/article/details/41131445
（1）HEAP_MAXIMUM用O(1)时间实现MAXIMUM(S)操作，即返回最大堆第一个元素的值即可（return A[1])。
（2）HEAP_EXTRACT_MAX实现EXTRACT_MAX操作，删除最大堆中第一个元素，然后调整堆。操作过程如下：将最堆中最后一个元素复制到第一个位置，删除最后一个节点（将堆的大小减少1），然后从第一个节点位置开始调整堆，使得称为新的最大堆。操作过程如下图所示：
伪代码
HEAD_EXTRACT_MAX(A) if heap_size[A]<1 ther error max = A[1] A[1] = A[heap_size[A]]; heap_size[A] = heap_size[A]-1 adjust_max_heap(A,1) return MAX（3）HEAP_INCREASE_KEY实现INCREASE_KEY，通过下标来标识要增加的元素的优先级key，增加元素后需要调整堆，从该节点的父节点开始自顶向上调整。操作过程如下图所示：
伪代码：
HEAP_INCREASE_KEY(A,i,key) if key < A[i] then error A[i] = key while i>1 && A[PARENT(i)] <A[i] do exchange A[i] <-> A[PARENT(i)] i = PARENT(i)（4）MAX_HEAP_INSERT实现INSERT操作，向最大堆中插入新的关键字。新的关键字插入在优先级的队尾部，然后从尾部的父节点开始自顶向上调整堆伪代码描述如下：
MAX_HEAP_INSERT(A,key) heap_size[A] = heap_size[A]+1 A[heap_size[A]] = -0; HEAP_INCREASE_KEY(A,heap_size[A],key)
上面是别人写优先队列的理解，我觉得很好，所以窃取过来.哈哈！
下面是自己根据伪代码写的：
#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
void swap(int *x, int *y)
{
int tmp = *x;
*x = *y;
*y = tmp;
}
//建立以root为i(即根节点为i)的最大堆，利用了递归的思想防止调整之后以largest为父节点的子树不是最大堆
void max_heapify(vector<int> &a, int i, int heapsize)
{
int l = 2 * i;//取其左孩子的坐标
int r = 2 * i + 1;//取其右孩子的坐标
int largest;//临时变量，用来保存r、l、r三个节点中最大的值
if (l <= heapsize&&a[l]>a[i])
largest = l;
else
largest = i;
if (r <= heapsize&&a[r]>a[largest])
largest = r;
if (largest != i)
{
swap(&a[i], &a[largest]);
max_heapify(a, largest, heapsize);
}
}
//***********************************************
//用自底向上的方法把数组转换成最大堆
void buil_max_heap(vector<int> &a, int heapsize)
{
int i;
//从heapsize/2+1到heapsize的节点都是叶节点，所以我们可以把他们都看成是包含一个元素的最大堆了
//所以从数组1到heapsize的有叶节点的节点建立最大堆
for (i = heapsize / 2; i >= 1; i--)
{
max_heapify(a, i, heapsize);
}
}
//1.返回堆中最大关键字的元素
int heap_max_inum(vector<int> a)
{
return a[1];
}
//2.去掉堆中并反会最大关键字的元素
int heap_extract_max(vector<int> &a, int &heapsize)
{
if (heapsize < 1)
cout << "there is no data in data" << endl;
int max = a[1];
a[1] = a[heapsize];
heapsize--;
a.pop_back();
max_heapify(a, 1, heapsize);
return max;
}
//3.将第i个元素的值增加到key
void heap_increase_key(vector<int> &a, int i, int key)
{
if (key < a[i])
cout << " error: new key is smaller than current key" << endl;
int p = i / 2;
a[i] = key;
while (i>1 && a[i] > a[p])
{
swap(a[i], a[p]);
i = p;
}
}
//4.将元素插入到集合中去。
void max_heap_insert(vector<int> &a, int key, int &heapsize)
{
heapsize++;
a.push_back(INT_MIN);
//a[heapsize] = INT_MIN;//给一个最小的负数，符合调用heap_increase_key
heap_increase_key(a, heapsize, key);
}
int main()
{
vector<int> a = { 0, 12, -3, 88, 52, 6, 4, 33, 2, 100, 5 };
int heapsize = a.size()-1;
cout << heapsize << endl;
buil_max_heap(a, heapsize);
for (auto i : a)
cout << i << " ";
cout << endl;
for (int i = 0; i < 10; ++i)
{
cout << heap_extract_max(a, heapsize) << endl;
for (auto i : a)
cout << i << " ";
cout << endl;
}
cout << heapsize << endl;
heap_increase_key(a, heapsize, 11);
for (auto i : a)
cout << i << " ";
cout << endl;
max_heap_insert(a, 55, heapsize);
for (auto i : a)
cout << i << " ";
cout << endl;
}
参考资料文献：http://www.cnblogs.com/Anker/archive/2013/01/23/2873951.html
再下面是别人用c++写的：
#include <iostream>
#include <string>
#include <cstdlib>
using namespace std;
const static int QUEUELEN = 100;
class Event
{
public:
Event():eventname(""),priority(-1){};
Event(const string &en,const int p):eventname(en),priority(p){};
Event(const Event& en)
{
eventname = en.eventname;
priority = en.priority;
}
~Event(){};
int get_event_priority()const
{
return priority;
}
string get_event_name()const
{
return eventname;
}
void increase_event_priority(const int k)
{
priority = priority + k;
}
void decrease_event_priority(const int k)
{
priority = priority - k;
}
void show_event() const
{
cout<<"Eventname is: ("<<eventname<<") and the priority is: "<<priority<<endl;
}
private:
string eventname;
int priority;
};
class PriorityQueue
{
public:
PriorityQueue();
void adjust_event(int index);
Event get_event()const;
void insert_event(const Event& en);
void increase_event_priority(int pos,int k);
Event delete_event(int pos);
void show_events() const;
~PriorityQueue();
private:
Event *events;
int length;
};
PriorityQueue::PriorityQueue()
{
events = new Event[QUEUELEN];
length = 0;
}
PriorityQueue::~PriorityQueue()
{
if(!events)
delete [] events;
length = 0;
}
//adjust max heap
void PriorityQueue::adjust_event(int index)
{
int left,right,largest;
Event temp;
while(1)
{
left = index*2;
right = index*2+1;
if(left <= length &&
events[left].get_event_priority() > events[index].get_event_priority())
largest = left;
else
largest = index;
if(right <= length &&
events[right].get_event_priority() > events[largest].get_event_priority())
largest = right;
if(largest != index)
{
temp = events[index];
events[index] = events[largest];
events[largest] = temp;
index = largest;
}
else
break;
}
}
Event PriorityQueue::get_event()const
{
if(length != 0)
return events[1];
else
return Event();
}
void PriorityQueue::insert_event(const Event& en)
{
length = length + 1;
events[length] = en;
increase_event_priority(length,0);
}
void PriorityQueue::increase_event_priority(int pos,int k)
{
int i,parent;
Event temp;
if(pos > length)
{
cout<<"error: the pos index is larger than queue length"<<endl;
return;
}
events[pos].increase_event_priority(k);
i = pos;
parent = i/2;
while(i>1
&& events[parent].get_event_priority() < events[i].get_event_priority())
{
temp = events[i];
events[i] = events[parent];
events[parent] = temp;
i = parent;
parent = i/2;
}
}
Event PriorityQueue::delete_event(int pos)
{
Event reten;
if(pos > length)
{
cout<<"Error:pos index is larger than queue length"<<endl;
return reten;
}
reten = events[pos];
events[pos] = events[length];
length--;
adjust_event(pos);
return reten;
}
void PriorityQueue::show_events() const
{
if(length == 0)
{
cout<<"There is no any event in the priority queue"<<endl;
}
else
{
cout<<"There are "<<length<<" events in the priority queue."<<endl;
for(int i=1;i<=length;i++)
{
events[i].show_event();
}
}
}
int main()
{
PriorityQueue pqueue;
Event en;
Event en1("fork",2);
Event en2("exec",3);
Event en3("wait",1);
Event en4("signal",6);
Event en5("pthread_create",5);
pqueue.insert_event(en1);
pqueue.insert_event(en2);
pqueue.insert_event(en3);
pqueue.insert_event(en4);
pqueue.insert_event(en5);
pqueue.show_events();
cout<<"\nThe max priority event is: "<<endl;
en = pqueue.get_event();
en.show_event();
cout<<"\nIncrese event3 by 7"<<endl;
pqueue.increase_event_priority(3,7);
en = pqueue.get_event();
en.show_event();
pqueue.show_events();
cout<<"\nDelete the first event:"<<endl;
pqueue.delete_event(1);
pqueue.show_events();
exit(0);
}
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- 算法导论 第六章优先队列C++实现
- 算法导论 第六章优先队列C++实现
- 算法导论-----最大优先队列
- （日志，《算法导论》.6.4）优先队列，堆，代码
- 算法导论：c++堆排序&优先队列
- 算法导论（min-priority-queue 最小优先队列的部分实现）
- 算法导论 第23章 最小生成树 斐波那契堆实现优先队列
- 算法导论第六章优先队列（二）
- 算法之优先队列
- uva 10047 The Monocycle(优先队列优化bfs)
- 优先队列（priority_queue）
- STL优先队列
- ROS最正确的限速--------小包优先+带宽均分+简单队列限制上传速度
- 用堆实现优先队列
- HDUOj 看病要排队 优先队列的使用 题目1873
- 《挑战程序设计竞赛》2.4.1 数据结构-优先队列 POJ2431 3253 3614 2010（3）
- hdoj 1873 看病要排队 【STL 优先队列】
- hdoj 1873 看病要排队 [STL 优先队列]
- 《算法导论》 6.5优先级队列
- 【优先队列】