求大师帮忙用C#语言写个程序：可视化 作业调度模拟（ 短作业优先算法实现）

Question

如题所述

Answer 1

参考一下吧。可能有一些错误，但这种想法是完全正确的。
优先级调度算法：
的＃include“stdio.h中”
包括“stdlib.h中”
“string.h中”
typedef结构节点BR /> {
字符名称[10]; / *进程标识符* /
诠释PRIO; / *进程的优先级号码* /
int的圆; / *处理时间的旋转时间片* /
诠释CPUTIME; / *进程的CPU时间* /
诠释needtime; / *进程还需要时间来完成* /
诠释计数; / *计数器* /
字符状态; / *进程状态* /
结构节点下; / *链指针* /
} PCB;
PCB *完成*准备好了，尾巴*运行/ *队列指针* /
整数N; / *进程数* /
/ *将就绪队列中的投入运行/
firstin的第一道工序，（）

运行做好了准备; / *就绪队列的头指针分配给正在运行的头指针* /
运行状态='R'/ *进程的状态更改为运行状态* /
准备准备>下; / *准备加工后移动到下一列头指针* /
}
/ *标题输出功能* /
无效PRT1（字符） BR /> {
（TOUPPER（）=='P'）/ *优先数的方法* /
printf的（“名称的CPU时间needtime优先状态\ n”）;
其他 BR />输出（“名CPUTIME needtime数轮状态\ N”）;
}
/ *进程PCB输出* /
无效PRT2（CHAR一，PCB * Q）
> {
（TOUPPER（）=='P'）/ *输出优先数* /
printf的（“％10％-10D％-10D - 10D％C \ N”， Q->名称，
Q-> CPU时间，Q-> needtime，Q-> PRIO，Q->状态）;
其他/ *旋转法输出* /
printf（“请％ 10％10D％-10D％-10D-10D-C \ n“，Q->名称，
Q-> CPU时间，Q-> needtime，Q->计数，Q->轮， Q->状态）;
}
/ *输出函数* /
无效PRT（炭算法）
{
PCB * p;
PRT1 （算法）; / *输出头* /
（run! = NULL）/ *如果你运行的指针不为空* /
PRT2（算法，运行）; / * PCB输出电流运行* /
P =准备; / *输出就绪队列PCB * /
（p! = NULL）
{
PRT2（算法，P）;
p =>下;
}
P =完成; / *输出完成队列PCB * /
（p! = NULL）
{
PRT2（算法，P）;
P = P->下;
}
的getch（）; / *按任意键继续* /
}
/ *优先数量的插入算法/
insert1（PCB * Q）
{
PCB * P1，* S * R;
INT B;
= Q; / *的PCB指针，是要插入* /
P1 =准备; / *就绪队列的头指针* /
R = P1; / * R P1前体的指针* /
B? = 1;
（（p1! = NULL）&& B）/ *优先数来确定插入的位置* /
（P1-> PRIO = S-> PRIO）
{
R = P1;
P1 = P1->下;
}
其他
B = 0;
（r! = P1）/ *如果条件成立之间插入R和P1 * /
{
R->下;
S-> = P1;
}
其他
{
S-> = P1; / *否则插入就绪队列中的头* /
准备;
}
}
/ *的轮转插入功能* /
insert2（PCB * P2）
{
尾巴 - > = P2; / *新的PCB插入在当前的就绪队列尾部* /
å°¾= P2;
P2->下一个= NULL;
}
/ *创建初始PCB信息优先数* /
无效create1 （CHAR ALG）
{
PCB * p;
我的时间;
字符不适用10];
准备= NULL; / *就绪队列的头指针* /
完成= NULL; / *完成队列的头指针* /
“运行=”NULL; / *运行队列的指针。 * /
printf的（“请输入名称和时间的流程\ n”）; / *输入进程ID和所需要的时间创建一个PCB * /
为（i = 1; <= N; + +）
{
p =的malloc（sizeof（PCB）的）;
scanf的（“％s”的，NA）;
scanf的（“％d的，与时间）;
使用strcpy（P->名称，NA）;
P-> CPU时间= 0;
P-> needtime的=时间;
P->状态='W'
P-> PRIO = 50;
如果（ready! = NULL）/ *就绪队列是没有空调的插入功能插入* /
insert1（P）; BR />其他
{
P-> =准备就绪; / *创建一个就绪队列PCB * /
准备=;
}
} <BR / clrscr（）;
printf（“请优先输出：\ n”）;
printf（“请********************* *************************** \ n“）;
PRT（ALG）; / *输出过程PCB * / />运行=准备就绪; / *就绪队列的处理操作* /
准备=准备就绪 - >下;
运行 - >状态='R';
}
/ *旋转的方法来创建进程PCB * /
的无效create2（字符ALG）
{
PCB * p;
我，时间;
字符娜[10] ;
准备好= NULL;
完成= NULL;
运行= NULL;
printf的（“输入姓名和时间的圆化处理\ n”）;
（我= 1 <= N + +）
{
P =的malloc（sizeof（PCB）的）;
scanf函数（“％s”，NA）</ scanf函数（“％d”，＆时间）;

使用strcpy（P->名称，NA）; P-> CPU时间= 0;
p->的needtime时间;
> P->计数= 0; / *计数器* /
的p-state ='W';
P->圆= 2; / *时间片* /
（准备好了！= NULL）
insert2（P）;
其他
{
P-> =准备就绪;
准备=;
å°¾= P
}
}
clrscr（）;
printf（“请输出轮\ n”）;
printf的（“********* *************************************** \ n“）;
PRT （ALG）; / *输出过程PCB信息* /
运行准备; / *队列的过程将在地方并投入运行* /
准备准备下;
>运行 - >状态='R';
}
/ *的优先级调度算法* /
优先（字符ALG）
{
而（跑！= NULL）/ *当运行队列不为空，正在运行的进程* /

运行 - > CPU时间=运行 - > CPUTIME +1;
运行> needtime运行 - > needtime-1;
运行 - > PRIO =运行 - > PRIO-3; / *每次的运行优先级降低3个单位的数量* /
（运行 - > needtime == 0）/ *如果已完成0插入队列* /
{
运行 - >下=完成;
完成运行;
运行所需的时间 - >状态='F'; / *设置状态来完成的状态* /
运行= NULL; / *运行队列的头指针是空* /
（ready! = NULL）/ *如就绪队列不为空* /
firstin（）; / *将制定一个过程，列操作* /
}
/ *没有运行完成，而给优先数是不是最大的，然后把它变成就绪状态，插入就绪队列* /
（（ready! = NULL）&&（运行 - > PRIO PRIO））
{
运行状态='W';
insert1（运行）;
firstin（）; / *就绪队列的第一个进程运行* /
>}
PRT（ALG）; / *输出过程PCB信息* /
}
}
/ * round-robin方法* /
roundrun（CHAR ALG）
{
（run! = NULL）
{
运行 - > CPU时间=运行 - > CPUTIME +1;
运行 - > needtime =运行 - > needtime -1;
运行计数运行计数+1;
（运行 - > needtime == 0）/ *运行后把它变成一个完整的状态，插入完成队列* /

{全部
运行 - >下=完成;
完成运行;
运行状态='F';
运行= NULL
（ready! = NULL）
firstin（）; / *准备列不为空，第一道工序的操作* /
}
其他
（运行 - >数==运行 - >圆）/ *如果时间片* /
{
运行 - >计数= 0; / *计数器设置为0 * /
（ready! = NULL）/ *就绪队列不空* /
{
运行状态='W'; / *将其插入就绪队列中等待旋转* / /> insert2（运行）;
firstin（）; / *将准备投入列正在运行的进程* /
}
}
PRT（ALG） / *输出过程的信息* /
}
}
/ *主函数* /
（）
{
字符算法; / *算法标记* /
Clrscr（）;

printf的（“类型的算法：P / R（优先/ ROUNDROBIN）\ n”）; scanf的（“％c”的算法）; / *输入字符确定算法* /
printf的（“请输入进程号\ n”）;
scanf的（“％d”，＆N）; / *输入的进程数* / BR />（算法=='P'| |算法=='P'）
{
create1（算法）; / *优先数* /
优先级（算法）;
}
其他
（算法=='R'| |算法=='R'）
{
create2（算法）; / *一轮循环* /
roundrun（算法）;
}
}赞同26 |评论

Answer 2

哇塞，听起来就好高级，也不知道是不是我没弄明白