优先级队列c语言
调度算法的实施过程如下所述：（1）应设置多个就绪队列，并为各个队列赋予不同的优先级。（2）当一个新进程进入内存后，首先将它放入第一队列的末尾，按FCFS的原则排队等待调度。当轮到该进程执行时，如他能在该时间片内完成，便可准备撤离系统；如果它在一个时间片结束时尚未完成，调度程序便将该进程转入第二队列的末尾，再同样地按FCFS原则等待调度执行；如果它在第二队列中运行一个时间片后仍未完成，再依次将它放入第三队列……，如此下去，当一个长作业进程从第一队列依次降到第N队列后，在第N队列中便采取时间片轮转的方式运行
⑵ C语言实现一个优先队列
#include <stdio.h>
#include <stdlib.h>
//数据列表结点结构体
typedef struct ListNode
{
int ndata;
int npriority;
struct ListNode *pNext;
};
//数据列表结构体
typedef struct DataList
{
ListNode *pHead;
ListNode *pLast;
int arPriorityInfoStore[11];
};
//生成链表变初始化，使用数据队列首先调用
DataList *CreateList()
{
int i;
//内存申请
DataList *list = (DataList*)malloc(sizeof(DataList));
//结构体初始化
list->pHead = list->pLast = 0;
for(i=0;i<11;i++)
{
list->arPriorityInfoStore[i] = 0;
}
return list;
}
/*!数据入队
* 参数list：数据队列链表
* 参数data：待入队的数据
* 参数prt ：待入队数据的优先级
* 返回值：布尔型，true为入队成功，false失败
*/
bool Insert(DataList *list,int data, int prt)
{
//内存申请
ListNode *pNewNode = (ListNode *)malloc(sizeof(ListNode));
//内在申请失败，无法入队
if(pNewNode = 0)
return false;
//新结点初始化
pNewNode->ndata = data;
pNewNode->npriority = prt;
pNewNode->pNext = 0;
list->arPriorityInfoStore[prt]++;
//区别对待第一个结点
if(list->pHead == 0)
{
list->pHead = list->pLast = pNewNode;
}
else
{
list->pLast->pNext = pNewNode;
list->pLast = pNewNode;
}
}
/*! 数据出队
* 参数list：数据队列链表
* 返回值：整型，优先最大的数据
*/
int Pop(DataList *list)
{
int nMaxPriority;
ListNode *pCursortNode;
//找出队列中的最大优先级
for(nMaxPriority = 10; nMaxPriority >= 0; nMaxPriority--)
{
if(list->arPriorityInfoStore[nMaxPriority]>0)
break;
}
//由于数据有效范围为0到100,故取-1作为无效值表示此时列表为空
if(nMaxPriority < 0)
return -1;
//找到优先级最大的点，取值返回
for(pCursortNode = list->pHead; pCursortNode->pNext!=0; pCursortNode = pCursortNode->pNext)
{
if(pCursortNode->npriority != nMaxPriority)
continue;
else
break;
}
return pCursortNode->ndata;
}
未进行测试，也未写主函数。功能函数已经写出，可能中间会有小问题，你调一下即能使用。
⑶ c语言中优先级队列如何实现优先级相同的元素先进先出
每次插入的时候进行排序
比较的时候，相同情况下，把后进的放在后面
然后从前面出队就可以了
⑷ c语言中有没有优先队列的头文件，如果有，请写出来
C标准库中没有优先队列呀，优先队列的C实现请参考博文：
《优先队列(priority_queue)的C语言实现(原创)》
http://hi..com/gropefor/blog/item/7d958eb68359cbe230add14e.html
⑸ ）用C语言（或其它语言，如Java）编程实现对N个进程采用某种进程调度算法（如动态优先权调度
公众：类PrivilegeProcess {
公共静态无效的主要（字串[] args）{
MyQueue的MyQueue的新MyQueue的（）;/ /声明队列
印刷电路板[PCB = {新的PCB（001 ，8,1），新的PCB（002,7,9），新的PCB（003,3,8），新的PCB（004,1,7），新的PCB（005,7,4）};
> PCB段=新的PCB（）;
（INT I = 0; <pcb.length; + +）{/ /初始化先进行排序，选择排序这里使用的是高优先级的一线队
（J =我; <pcb.length; J + +）{
（PCB [I]。特权<PCB [J]。特权）{
段= PCB [1];
PCB [I] = PCB [J];
PCB [J] =段;
}
}
}
体系。通过out.println（“入队后第一时间的进程的顺序：”）;
（INT I = 0; <pcb.length; + +）{
的System.out调用println（第一次入队＃程序名称：“+ PCB [我]。名称+ totaltime：”+ PCB [I]。totaltime +“的”特权“+ PCB [我]。特权）; }
（）;
myqueue.start（PCB）;
}
}
类MyQueue的{
INT指数= 0;
PCB [] PC =新的PCB [5];
PCB [] PC1 =新的PCB [4];
PCB温度=新的PCB（） BR />公共无效排队（PCB工艺）{/ /排队算法
（指数== 5）{
（“出界！”）;
返回
}
PC [索引] =进程;
指数+ +;
}
公共：PCB DEQUEUE（）{/ /出队算法（索引== 0）
返回空;
（INT I = 0; <pc1.length; + +）{
PC1 [I] = PC [ +1];
}
指数 -
温度= PC [0];
（INT I = 0; <pc1.length; + +）{ BR /> PC [I] = PC1 [I];
}
回报条件;
}
公共无效启动（PCB [] PC）{/ /进程表算法
（PC [0]。isNotFinish ==真| | PC [1 isNotFinish ==真| | PC [2 isNotFinish ==真| | PC [3]。时isNotFinish ==真| | PC [4]。isNotFinish ==）{
/ / *注：| |运算符都是假的，所有的表达式结果为假，否则真
（INT I = 0; <PC长度; + +）{
PC [I]。运行（这一点）; />} 的System.out.println（）;
（INT I = 0; <pc.length; + +）{/ /处理每个运行一次运行的时间片的长度重新排序优先一旦
（J =我; <pc.length; J + +）{
如果（PC [I]特权<PC [J]。特权）{
温度= PC [I];
PC [I] = PC [J];
PC [J] =温度;
}
}
}
}
}
}
类PCB {/ /声明过程级
和int名，totaltime ，运行时特权;
布尔isNotFinish的;
公众PCB（）{
}
公开PCB（名称，诠释totaltime特权）{
this.name =的名称;/ /进程名
this.totaltime = totaltime ;/ /
this.privilege =特权;/ /总时间优先 this.runtime = 2 ;/ /时间片值是2
this.isNotFinish =真;/ /是否执行完成
（“初始值：程序名称：”+名+“totaltime：”+ totaltime +“特权”+特权）;
System.out的。调用println（）;
}
MyQueue的MQ公共无效的run（）{/ /处理的基础上实施的时间片算法
（totalTime> 1）{ totaltime =运行;/ /总时间大于1，总时间=总时间 - 时间片
特权 -
（“程序名称：”+姓名+“ remaintime：“+ +”特权“+特权）; totaltime
的} else if（totaltime == 1）{
totaltime - ;/ /总时间为1时，执行时间为1
>特权 -
（“程序名称：”+姓名+“remaintime：”+ totaltime +“特权”+特权）;
}其他{
isNotFinish =假;/ / 0，将isNotFinish标志设置为假
}
如果（isNotFinish ==真）{br mq.deQueue（）;
mq.enQueue（本）;
}
}
}