优先队列C++实现和应用

#include<iostream>

#include<stdlib.h>

using namespace std;

//优先级队列数组元素的个数

const int MaxPQSize = 50;

template<class T>

class PQueue{

private:

int count;

T pqlist[MaxPQSize];

public:

PQueue(void);

void PQInsert(const T& item);

T PQDelete(void);

void ClearPQ(void);

//检测优先级队列状态操作

int PQEmpty(void)const;

int PQFull(void)const;

int PQLength(void)const;

};

template <class T>

PQueue<T>::PQueue(){

count = 0;

}

template<class T>

int PQueue<T>::PQEmpty() const{

return count==0;

}

template<class T>

void PQueue<T>::PQInsert(const T& item){

if(count == MaxPQSize){

cerr<<"队列已经溢出了!"<<endl;

}

//将元素置于队尾并使count+1

pqlist[count] = item;

count++;

}

//将尾元素放进最大优先级元素处 count--

template<class T>

T PQueue<T>::PQDelete(){

T min;

int i,minindex = 0;

if(count > 0){

//在pqlist中找到最小值极其下标

min = pqlist[0];//假设第一个元素为最小值

//顺序访问元素 修改最小值 及下标

for(i = 1; i < count; i++)

if(pqlist[i] < min){

min = pqlist[i];

minindex = i;

}

//将尾元素移入最小元素处并将count减一

pqlist[minindex] = pqlist[count-1];

count--;

}else{

cerr<<"deleting from an empty pqueue"<<endl;

}

return min;//返回最小值

}

//应用

#include <iostream>

#include<iomanip>

#include<fstream>

#include"PQueue.h"

/* run this program using the console pauser or add your own getch, system("pause") or input loop */

//定义请求单的记录

enum Staff{Manager,Supervisor,Worker

};//员工类型 Manager 优先级最高

struct JobRequest

{

Staff staffPerson;

int jobid;

int jobTime;

};//工作状态

int operator<(const JobRequest& a,const JobRequest& b){

return a.staffPerson < b.staffPerson;

}

void PrintJobInfo(JobRequest PR){

switch(PR.staffPerson){

case Manager:

cout <<"Manager    ";

break;

case Supervisor:

cout<<"Supervisor    ";

break;

case Worker:

cout<<"Worker    ";

break;

}

cout<<PR.jobid <<"    "<<PR.jobTime<<endl;

}

void PrintJobSummary(int jobServicesUse[]){

cout<<"\nTotal Support Usage\n";

cout<<" Maager   "<<setw(3)

<<jobServicesUse[0]<<setw(3)<<endl;

cout<<" Supervisor  "<<setw(3)<<jobServicesUse[1]<<endl;

cout<<" Worker   "<<setw(3)<<jobServicesUse[2]<<endl;

}

int main(int argc, char** argv) {

//处理不超过50个服务请求单

PQueue<JobRequest> jobpool;

//从fin中读入服务请求单

ifstream fin;

//为每类员工服务的时间

int jobServicesUse[3]={0,0,0};

JobRequest PR;

char ch;

//打开输入文件 job.dat 若失败则退出程序

fin.open("job.dat",ios::in);

if(!fin){

cerr<<"cannot open file job.dat"<<endl;

}

//从文件读入每个请求并插入到优先队列jobpool中

//每行开始为表明员工类别的字符

while(fin>>ch){

switch(ch){

case‘M‘: PR.staffPerson = Manager;

break;

case‘S‘: PR.staffPerson = Supervisor;

break;

case‘W‘: PR.staffPerson = Worker;

break;

default: break;

}

//读入PR的jobid 和jobtime

fin>>PR.jobid;

fin>>PR.jobTime;

//将PR插入到优先级队列

cout<<PR.jobid<<"****"<<endl;

jobpool.PQInsert(PR);

}

//从优先级队列中删除服务并输出该服务的信息

cout<<"Category Job ID Job Time"<<endl;

while(!jobpool.PQEmpty()){

PR = jobpool.PQDelete();

PrintJobInfo(PR);

//对每类员工累计服务时间

jobServicesUse[int(PR.staffPerson)]+=PR.jobTime;

}

PrintJobSummary(jobServicesUse);

return 0;

}

版权声明:本文为博主原创文章,未经博主允许不得转载。

时间: 2024-11-10 15:07:24

优先队列C++实现和应用的相关文章

51nod1428(优先队列)

题目链接:http://www.51nod.com/onlineJudge/questionCode.html#!problemId=1428 题意:中文题诶- 思路:贪心 问最少要多少教室就是求最多有多少个时间段产生了交集咯.我们先用结构体存储区间并将其按照左端点升序排列,若左端点相同则按右端点升序排列. 接下来遍历所有区间,并维护一个优先队列,其中存储区间右端点值.对于当前区间,我们将优先队列中所有比当前区间左端点小的元素删除(因为其所在区间不会与当前区间相交嘛),然后再将当前区间的右端点加

优先队列实现哈弗曼最小权值

建立哈弗曼树要求我们每次都选频率权值最小的点构成节点,即权值小的点在树的深处,权值大的点在树的浅处,根据节点选择的特点,我们可以把节点的值放在优先队列中,包括新形成的节点. 我们先定义优先队列的优先级别. 1 struct cmp 2 { 3 bool operator()(const int &a,const int &b) 4 { 5 return a>b; 6 } 7 };//最小值优先出队 然后就是实现的整个程序. #include<stdio.h> #inclu

NYOJ 284 坦克大战 &amp;&amp; POJ 2312 Battle City (广搜+优先队列)

链接:click here~~ 题意: 描述 Many of us had played the game "Battle city" in our childhood, and some people (like me) even often play it on computer now. What we are discussing is a simple edition of this game. Given a map that consists of empty space

hdu 4006 The kth great number(优先队列)

The kth great number Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65768/65768 K (Java/Others) Total Submission(s): 6982    Accepted Submission(s): 2837 Problem Description Xiao Ming and Xiao Bao are playing a simple Numbers game. In a roun

优先队列(堆)

一.优先队列的一些简单的实现: 1. 使用一个简单的链表在表头以O(1) 执行插入操作,并遍历该链表以删除最小元,这需要O(N) 的时间. 2. 始终让表保持有序状态:这使得插入代价高昂(O(N)), 而删除代价低廉(O(1)).基于删除最小元的操作从不多于插入操作的事实,因此,前者是更好地想法. 3. 使用二叉查找树,它对这两种操作的平均运行时间是O(logN).尽管插入是随机的,而删除不是,但这个结论还是成立的.由于删除的唯一元素是最小元.反复除去左子树中的节点似乎损害树的平衡,使得右子树加

优先队列比较符重载

#include <iostream> #include <queue> using namespace std; struct Node{ int x, y; friend bool operator<(Node a, Node b){ return a.x > b.x; //x最小的节点在队首 } }; int main(){ priority_queue<Node> PQ; Node temp = {2, 3}; PQ.push(temp); temp

[ACM] hdu 1242 Rescue (BFS+优先队列)

Rescue Problem Description Angel was caught by the MOLIGPY! He was put in prison by Moligpy. The prison is described as a N * M (N, M <= 200) matrix. There are WALLs, ROADs, and GUARDs in the prison. Angel's friends want to save Angel. Their task is:

1475 建设国家(优先队列)

1475 建设国家 基准时间限制:1 秒 空间限制:131072 KB 分值: 20 难度:3级算法题 小C现在想建设一个国家.这个国家中有一个首都,然后有若干个中间站,还有若干个城市. 现在小C想把国家建造成这样的形状:选若干(可以是0个)的中间站把他们连成一条直线,然后把首都(首都也是一个中间站)连在这一条直线的左端.然后每个点可以连一个城市,特别的是最右端的点可以连接两个城市. 现在有n个城市的规划供小C选择.但是,他们那儿的交通条件比较差,他们那儿一天是2*H个小时,每个城市里面的人每天

Battle City BFS+优先队列

Battle City Many of us had played the game "Battle city" in our childhood, and some people (like me) even often play it on computer now. What we are discussing is a simple edition of this game. Given a map that consists of empty spaces, rivers,

堆与优先队列

当我们需要高效的完成以下操作时: 1.插入一个元素 2.取得最小(最大)的数值,并且删除 能够完成这种操作的数据结构叫做优先队列 而能够使用二叉树,完成这种操作的数据结构叫做堆(二叉堆) 堆与优先队列的时间复杂度: 若共有n个元素,则可在O(logn)的时间内完成上述两种操作 堆的结构如下图: 堆最重要的性质就是儿子的值一定不小于父亲的值,且堆从上到下,从左到右紧密排列. 堆的操作: 当我们希望向堆中插入元素时,堆的内部会进行如下操作(以插入元素3为例): (1.在堆的末尾插入该值) (2.不断