优先级调度算法

杨利霞

& E/ m) k. S4 b. x8 y+ e% [% p& H优先级调度算法

算法介绍
优先调度算法的类型（用于作业调度）
1）非抢占式优先权调度算法
- m2 D/ ?$ N1 r, g系统一旦把处理机分配给优先权最高的进程后，便一直执行下去，至完成。
2）抢占式优先权调度算法
只要系统中出现一个新的就绪进程，就进行优先权比较 。若出现优先权更高的进程，则立即停止当前执行，并将处理机分配给新到的优先权最高的进程。

优先权类型
1）静态优先权
9 v" j# `3 v1 Z! D% G静态优先权在创建进程时确定，且在进程的整个运行期间保持不变。

2）动态优先权
9 R, |6 \: ]" b! u

算法实现

抢占式动态优先权：

PS：本人认为非抢占式静态优先权没有实际价值。

• 
  
  #include <stdio.h>
  * G( w  ^( B0 c3 s$ g. W+ \1 m
  
• 
  
  5 J) R% W- {3 N9 d% p9 |#include <stdlib.h>  
  ( U/ g1 k5 E7 G7 O7 z1 w1 }9 y
  " ?+ e: ~9 L' A" b
• 
  % M6 M2 F9 b4 k
  #include <string.h>  
  ; _5 R. i% M9 P( {0 S# U8 N& ]
  ( @$ Q$ z5 q' z/ H
• 
  - m8 G: d' v# ?" @# v. B& p
  typedef struct node  
  
  
• 
  
  {  
  9 s# E& d) _. O1 W3 v
  
• 
  
     char name[10];  /*进程标识符*/  
  1 f5 w, K7 ?" p$ F% z
  
• 
  
     int prio;   /*进程优先数*/  
  
  
• 
  " X1 p  r1 T8 u1 l5 c5 v
  ) Y1 q- v$ l3 E# {$ R8 @: v   int round;  /*进程时间轮转时间片*/  
  $ x4 h* G, U6 D* P5 A) P
  
• 
    k6 @, A( E+ S# d$ h. i
     int cputime; /*进程占用CPU时间*/  
  
  
• 
  4 l* f# s: I$ W2 x3 R7 l$ A" n
     int needtime; /*进程到完成还要的时间*/  
  1 r& R4 P0 a5 {6 G( U* U! X! O
  3 E) h' w* D- O/ U5 ?/ k
• 
  
  ! g: x9 _6 E8 T; V- n2 y' o( h, E   int count;  /*计数器*/  
  
  ( A* k9 v+ A) a1 J. S1 v, `0 L
• 
  
     char state; /*进程的状态*/  
    D0 ~( W3 a4 p5 o* t. C+ V: n; f/ k
  7 b4 r& {5 B5 r7 ?
• 
  2 M0 W) j1 |& d2 c7 p- Y
     struct node *next; /*链指针*/  
  . N* E5 Y- U# s" F- ]3 T
  - G: h8 s( t$ I+ b. T
• 
  ; s/ y' ], B9 ~6 N) I8 F+ c1 s
  5 A6 d* R5 X) }7 ?+ u5 S}PCB;  
  
  " i1 }  w! x0 P1 o' H! X6 z
• 
  
  $ y# \1 z4 U( l3 W! M4 qPCB *finish,*ready,*tail,*run; /*队列指针*/  
  0 j& ?4 ]3 z" N% h- }2 ?" ?
  8 B/ D) d5 y5 d4 s$ y3 ~. N$ F
• 
  $ Z& i, k8 s- O" K8 r
  + k' s! ?* z! M5 wint N; /*进程数*/  
  
  
• 
  0 m0 h2 l: Q3 y8 h# X
  /*将就绪队列中的第一个进程投入运行*/  
  
  
• 
  
  3 E5 n1 [1 a, G8 P7 l. ^7 lfirstin()  
  / ]& j! s, |( ^
  7 I- R& z0 q) t/ ~( L5 z" f
• 
  
  {  
  & X$ L& M. I' f) C9 V3 V
  
• 
  
     run=ready;   /*就绪队列头指针赋值给运行头指针*/  
  ' C# e( ?0 a" z- ^' i9 C* _2 g7 `8 h1 I
  ; C2 E0 v! G: b2 ~* s
• 
  * ?4 f! q/ ^8 `2 i
  : A  b( J/ m9 \5 d   run->state='R';   /*进程状态变为运行态*/  
  / \$ r- P! y: f& u& }; d
  
• 
  
     ready=ready->next;  /*就绪对列头指针后移到下一进程*/  
  * O. F; s% q5 |0 d; }; _
  
• 
  & ~5 K- c# Y, ]# G. \* o
  }  
  + p2 L$ s( j$ `, E, k! I8 _
  
• 
  
  , m/ i0 Q8 Y8 x2 m# ^& [* t* d3 _/*标题输出函数*/  
  
  
• 
  
  4 ?* o# x7 W( O7 H" w' J1 ?) l7 W: Bvoid prt1(char a)  
  
  
• 
  7 d7 _+ J* p; y  G; x
  . \2 `+ X* {1 F1 ?{  
    u0 {# F: K$ |0 L" x) W
  
• 
  
  - r6 U: P& _- z- I2 b2 p( N! Y1 ]+ s# ?   if(toupper(a)=='P') /*优先数法*/  
  & R5 [% `7 b8 Q# g) l# }
  
• 
  - e$ O/ B2 l) |  V
        printf("  进程号   cpu时间  所需时间  优先数    状态\n");  
  
  , |5 ?; G0 `9 |+ P3 P8 |
• 
  
  5 k/ l; E$ f7 x   else  
  / H4 a: Y0 N- T6 F! H7 R9 q
  ' Z1 n/ m$ @+ Q+ p3 u2 A
• 
  ! ~7 V, F! f  t: y& c
  0 R% g3 G) j/ R8 L5 j* N: }      printf("  进程号   cpu时间  所需时间   记数   时间片       状态\n");  
  
  / ]$ {" i+ D8 A; R
• 
  , k$ F" B/ ?8 l/ d
  : ]! m" }# ]2 y5 N/ m) O}  
  ( l( I' j! h7 P- {! M
  
• 
  
  /*进程PCB输出*/  
  ( [0 b( k# T, z9 c
  " D4 w. |) z  }
• 
  
  void prt2(char a,PCB *q)  
  2 R7 j0 y/ ]* a! `
  
• 
  
  {  
    R4 U+ O, C7 ^: a
  . t. P' Z# g$ D% X( g0 `
• 
  
  $ a# G& O3 E7 y  G   if(toupper(a)=='P')  /*优先数法的输出*/  
  3 E7 Q( e+ w7 Z; s
  
• 
  : W& G/ F( P% z4 _
        printf("  %-10s%-10d%-10d%-10d %c\n",q->name,  
  % A/ R. \3 B; _" h7 u
  8 P- x% a/ N4 N/ b$ T# C
• 
  6 x5 c# o( F; B; \; O5 G. ~/ S
         q->cputime,q->needtime,q->prio,q->state);  
  6 U3 Q' N* k1 k5 H5 T
  
• 
  
     else/*轮转法的输出*/  
  
  ! x% w+ t2 i* p
• 
  , A6 h  F7 Q2 L
        printf("  %-10s%-10d%-10d%-10d%-10d %-c\n",q->name,  
  
  
• 
  9 {& {3 [1 g+ n) X8 x1 O! A
  1 q" R8 C8 M9 f+ m% v6 |       q->cputime,q->needtime,q->count,q->round,q->state);  
  
  : T, t+ l7 O% S' R; @$ w
• 
  0 B# G: c+ J2 O& a2 l& \' K
  }  
  
  
• 
  
  /*输出函数*/  
  
    V* [  ~5 ~. k9 D
• 
  
  void prt(char algo)  
  
  
• 
  
  {  
  
  
• 
  
     PCB *p;  
  0 c( S; r3 f3 l6 r7 p& [. f- Y  r
  
• 
  
     prt1(algo);  /*输出标题*/  
  3 c$ q# `. R4 T' ?; b0 G: L
  
• 
  0 @* \7 X, g$ X2 K2 y1 L4 l8 C1 y
     if(run!=NULL) /*如果运行指针不空*/  
  
  
• 
  
  # W% S8 [8 ?- r4 b% u      prt2(algo,run); /*输出当前正在运行的PCB*/  
  & e* C, x- s4 [' F" c7 G
  
• 
  % V& B+ T- Q5 K" {" q
  1 e. I/ C7 m! U   p=ready;  /*输出就绪队列PCB*/  
  
  ( U0 Z. I- k. `9 G
• 
  
     while(p!=NULL)  
  & A% z; @1 e+ V1 E  B7 S
    I! E! n7 n' ?0 E% L
• 
  9 x: J( }) w4 A( V3 ~) t
  8 G/ C: C, S) B7 ^   {  
  ( X! ^! ~" E0 Y' W' ?9 D
  5 T  {8 b! m. k
• 
  
  ' Z8 @% t+ a1 c      prt2(algo,p);  
  
  : T% P- p: o& n5 n6 g
• 
  " W8 e& v, y6 P: r# U
        p=p->next;  
  
  
• 
  
     }  
  
  + F2 J5 q1 v& D6 e  F; y: |
• 
  
     p=finish;  /*输出完成队列的PCB*/  
  
  
• 
  
     while(p!=NULL)  
  % L& K2 z; [0 i7 V# y0 _% B
  6 }3 Z/ G) n6 ?/ L5 x) M" ]5 ^9 o
• 
  8 L) J$ {* `* e, S9 G5 x! |
     {  
  & T  n* Z7 _( C( p6 ]" u! u
  3 `2 s# U# e. m0 f, ^& c$ k( \
• 
  
  - ^# M& W( |6 k0 M# p      prt2(algo,p);  
  ( g& c3 ~5 ~" h  n" G
  
• 
  
        p=p->next;  
  + x! e% [0 H; g# i+ g7 H
  
• 
  
  . ^/ Q+ F! O& K   }  
  ) u4 J, H5 R% p% s
  
• 
  
     getchar();  /*压任意键继续*/  
  ( p* t/ |6 s, W! i- a
  
• 
  
  }  
  
  
• 
  ( Q% H8 F7 g0 f4 a: q8 R- l% o
  ) k8 E% C  u7 [( V/ X) L/ H/*优先数的插入算法*/  
  % B8 {* e% m, X5 \
    x. u" d1 \# l
• 
  
  insert1(PCB *q)  
  
  ' t- s4 w9 J8 V7 ^: g
• 
  
  {  
  
  8 O) \* z/ k+ d" p, o' [
• 
  7 A, L5 q0 o7 K4 Z
  " ]/ z- n8 q! u' r$ h   PCB *p1,*s,*r;  
  
  ; v2 m9 }& O6 \
• 
  
     int b;  
  
  
• 
  
     s=q;  /*待插入的PCB指针*/  
  
  
• 
  ! O7 Y) ~1 M) w' X
     p1=ready; /*就绪队列头指针*/  
  
  
• 
  + S! g# g! [2 N& L$ ?1 ?) A: |1 G
  * S: I4 A* _% v4 m$ G4 V$ {# E9 l   r=p1; /*r做p1的前驱指针*/  
  ( X6 E' N% P7 l& v8 {, ]7 O' \
  1 Z  s" X: `* V
• 
  
  9 H, _9 N) N6 D5 `; m/ m: v% j! E9 K7 ]   b=1;  
  
  : ^/ @! s& W( E2 S( r/ v
• 
  
     while((p1!=NULL)&&b)  /*根据优先数确定插入位置*/  
  0 k' m6 L3 F* s5 y' u+ z1 q
  9 W3 C( a% o9 r) J. W
• 
  " a5 Z2 R$ @- I; R  p
        if(p1->prio>=s->prio)  
  
    l+ n' B. ^9 p5 p& G! S
• 
  & i' |; S- |& w* F
  , E4 F8 D$ Y1 h/ N      {  
  
  
• 
  
       r=p1;  
  
  - ~' R6 ^0 m8 l3 J- M2 L) \$ R
• 
  / C! h3 a  |8 y/ C
  - n8 R0 z, e6 J' I     p1=p1->next;  
  - D# {3 ?0 i* @# r9 p9 _1 R( D
  
• 
  " W7 m. d; T8 R# p' ?3 h1 o9 S6 x
        }  
  + M* A8 T+ f1 T6 E# R7 Z7 T0 D
  2 n: j) O* y2 x, X; h: j3 H% I
• 
  
        else  
  * G- y# d+ U4 F  `7 s
  * l# x0 d6 K  ]0 [
• 
  9 t1 J7 z2 Z( W& b- |7 E+ \
  " W5 D, Y9 z$ f" `     b=0;  
  
  
• 
  * U7 g* t. A6 O5 w8 _2 ^" C/ V
     if(r!=p1)  /*如果条件成立说明插入在r与p1之间*/  
  
  
• 
  
    Y- d9 F3 c7 G- E3 \5 U   {  
  
  . g: w8 G# m$ K/ ~
• 
  
  & M; Y& R( Z4 M7 E3 y  [% f      r->next=s;  
  9 A) e) R0 l) `- l6 u! h
  . H, r! f" c4 c7 N, v
• 
  ; @7 t+ s, T# }4 Z6 b+ k1 K4 D  S5 j
        s->next=p1;  
  6 C' S2 @7 ]. O5 _5 r
  
• 
  
  5 g8 s! f4 ~5 f' G( J   }  
  
  
• 
  5 \$ c9 O2 @% t& u/ L7 [4 o
     else  
  
  & c# C* @' \/ v+ R, M; i# a4 a# E; T
• 
  3 f3 ]# B& c7 o5 W
     {  
    Z* O7 K2 O) E# A* s; A4 {( K
  # w) ]. z( d, n0 ~- b3 V/ ?. ^
• 
  
        s->next=p1;  /*否则插入在就绪队列的头*/  
  * W6 U/ d. |( e/ y& }4 r
  2 D7 }: i. D8 E6 T% l0 g
• 
  
        ready=s;  
  1 b8 |+ S4 b% J# W/ m' t0 U0 V
  
• 
  , Q6 x, B7 w, u/ D. I" o2 i9 e' |- p3 z
  4 N+ C* d6 S4 E   }  
  % O8 [( a) Q7 V: w$ C
  
• 
  6 C/ w' |: r, \! f# M0 x- h
  }  
  
  ! ~1 m  y- {! ?* k6 c, [, E( s" e
• 
  
  ' C  C% x' ]  E% |# r/*优先数创建初始PCB信息*/  
  
  5 L& g' \+ Y$ B! t. l  V" Y; h6 `
• 
  9 q5 ?: A0 A: Q5 |; L
  void create(char alg)  
  " O$ k8 F* g- ]6 e% a
  - r: a& E8 J  I2 s% |
• 
  ' L  u2 E$ q) ]4 P# M
    t3 ]0 y$ N5 l* V* j{  
  
  
• 
  
     PCB *p;  
  : d/ u' w: |5 e) v2 O2 w
  1 V, w0 j( k& {% C; w/ ^. C
• 
  # q6 \; L. c. d+ ?4 t4 C6 Z
  9 E" U$ J9 l6 p2 D5 }+ ~   int i,time;  
  9 o' n! g' Y" s! D, T: P
  
• 
  ' c7 ]$ u! {6 {* ]+ o
  & E! k; B5 M2 s2 p1 }* ^* E# g   char na[10];  
  
  $ k  w* b/ s! a9 L
• 
  6 C0 w1 ]: f5 u8 T
     ready=NULL; /*就绪队列头指针*/  
  ; L" u) L7 E( [& I1 g
  . u" {4 x% o9 A7 b1 @
• 
  
  , x, s& r- d4 A$ l! a% Y! F/ X   finish=NULL;  /*完成队列头指针*/  
  7 [. N5 K) h- v( j
  ! F# ]: W8 O5 e1 w
• 
  " x3 O  k% i; X& o! Z' x
  ( K) x. W0 Y- d0 f  E% W   run=NULL; /*运行队列指针*/  
  # B: |/ I1 |/ \% I% j
  . y) V  \; m2 Q# |
• 
  
  / W9 ~/ e" a- S) S! n) N- @   printf("输入进程号和运行时间：\n"); /*输入进程标识和所需时间创建PCB*/  
  / t: H5 s( p9 V  o( z
  . H" v. l- v. I2 _6 D0 N+ N
• 
  + y7 t* Q" x, V' L) S. v9 M* a8 X0 V
     for(i=1;i<=N;i++)  
  
  
• 
  * q: m+ m: E5 J
  $ I+ W! z) x4 I0 I# q   {  
  
  
• 
  
  " c( v" s# H+ L* R6 `      p=(PCB *)malloc(sizeof(PCB));  
  ' X+ H" q. R# J* s; Y
  
• 
  
        scanf("%s",na);  
  , I; j! R. @& u; Y+ |+ W  z8 K1 K
  
• 
  
  ; \- M1 v6 H8 P% W% Z; h      scanf("%d",&time);  
  
  9 F6 f" z# f$ }
• 
  3 Q6 ~3 o' d2 Z% O4 R
  . c/ e' u) F6 D. ?$ s* @0 ?      strcpy(p->name,na);  
  3 h1 B; ?; d4 m2 G2 E# Q# c& `) ?
  
• 
  
  3 r! H, ~: S( D; y5 a4 l( F0 L' @      p->cputime=0;  
  
  1 o5 D, a5 Q. T" ]7 }
• 
  - ~( C% ~! {( p6 x( {
        p->needtime=time;  
  $ |5 H# ?, J) c3 \& r( g, \6 m
  
• 
    E8 G/ y& o1 l. s( B
  6 n: Y0 |8 `6 s0 B' [4 d9 a% u      p->state='w';  
  + n; n2 h& X- B6 |2 H
  
• 
  + ^  j5 d3 ?6 R6 O) {
  7 E( d+ P6 \& X! x8 h  h0 Q: g. k      p->prio=50-time;  
  
  
• 
  
        if(ready!=NULL) /*就绪队列不空调用插入函数插入*/  
  
  1 R1 V3 C5 ]4 |% F( O
• 
  
       insert1(p);  
  
  8 Q2 G7 e4 _, f2 R- R3 x- Y) |
• 
  1 O. o" W9 @- x- g4 Q3 R0 q, f5 {
        else  
  ( O9 ~& h& x4 \# k% @. H
  
• 
  # D+ H! y/ y) C- m$ d1 C
  4 H) z% I+ S1 D+ G0 J* Y8 A      {  
  + G  g: U* F4 l# @* g
  + }; K" |( t& X, b
• 
  
    `4 v; ^. p2 z4 m8 O4 C     p->next=ready; /*创建就绪队列的第一个PCB*/  
  
  
• 
  
       ready=p;  
  
  
• 
  
        }  
  0 @! K( ~$ P, Y  \; z& c
  1 K5 L% M2 `, D1 E7 Z: B
• 
  7 B$ I! ?3 E2 T" s9 k
  $ D( T3 |3 u7 k   }  
  
  4 |/ r$ m# E( j8 V
• 
  ! w1 n7 R/ L2 v1 ], W, |
     printf("          优先数算法输出信息:\n");  
  
  , T1 R* X* T& Z& }' U
• 
  - M) U& S- d/ E/ x
     printf("************************************************\n");  
  
  
• 
  
  % C) Z: Q( S3 M' A' M' [2 t   prt(alg);  /*输出进程PCB信息*/  
  
  
• 
  1 b( [; \% c2 x0 {  O8 _1 \6 _# Y
  6 s+ x! f  L' K; ^   run=ready; /*将就绪队列的第一个进程投入运行*/  
  6 `( `' K( O2 r! ?, k9 L( q1 E. {
  ) }. D1 V6 |$ v( U8 L' _2 M; r
• 
  9 g' e( z% V9 [  p/ _
  - l! i- V* ^9 F9 C. \   ready=ready->next;  
  8 x3 S6 ^9 d; E! m
  
• 
  
  & j6 m- S6 z$ y+ @   run->state='R';  
  
  
• 
  
  }  
  
  / X: j) c1 X5 x; C+ I
• 
  
  /*优先数调度算法*/  
  $ @' }( n% r/ N: }3 z
  
• 
  
  & F) C" q6 B2 @priority(char alg)  
  
  5 M- @4 B; Y' F) e# Y- k7 s: D
• 
  
  {  
  
  * F1 E2 S+ t: k  Y$ h/ e  R& ]
• 
  # X8 }3 M/ v# f  a
     while(run!=NULL)  /*当运行队列不空时，有进程正在运行*/  
  
  
• 
  
     {  
  
  : P3 w$ S2 ?9 u' F$ E
• 
  0 _$ a3 O7 R6 |2 g/ I* o
  ! ?* O) @( _6 t: n      run->cputime=run->cputime+1;  
  $ I( x6 t8 y. w7 i" q& I
  
• 
  8 c" D3 s8 O: k7 ?! _: t
        run->needtime=run->needtime-1;  
  
    E0 W! b0 e: w* q" R, b
• 
  
        run->prio=run->prio-3; /*每运行一次优先数降低3个单位*/  
  
  
• 
  
        PCB *p;
  
  
• 
  $ P" j/ Q) X: A6 \! ?! H
        p=ready;
  
  
• 
  
  # i0 w& e3 O; t7 h      while(p!=NULL)  
  & z; K$ Z- w$ p/ X
  ) u) J. Z3 f, [' w, h' F
• 
  
        {  
  % e& J) ?# u( A* Y! d1 A3 B
  
• 
  
            p->prio=p->prio+1; /*每等待一次优先数升高1个单位*/   
  
  
• 
  
            p=p->next;  
  
  3 p4 v$ E3 a% k& `% b* R
• 
  : i* c1 ?% n! X
        }  
  ) m( y7 S9 ~5 g) p5 I
  / X1 s4 j  x  Q" ~; ?) c
• 
  
        if(run->needtime==0)  /*如所需时间为0将其插入完成队列*/  
  
  
• 
  8 Y0 Q+ m! P5 h$ n
  , I" s* B9 o( E! p      {  
  
  
• 
  
           run->next=finish;  
  
  
• 
  
  " C3 q- ~" d4 V4 L/ ?         finish=run;  
  
  1 D5 ?& U/ _1 u/ }- B6 n
• 
  6 `* g1 {6 _* ~# g* Y8 C6 Q' S3 t
  ! l: K% U& v3 O- A* {, C. {         run->state='F';  /*置状态为完成态*/  
  
  + j! c0 }+ C' D
• 
  
  ) n5 P) h) i8 x+ g, F$ N$ b' m# w         run=NULL;  /*运行队列头指针为空*/  
  
  
• 
  $ q- c/ O9 B% t6 T* u; n% r* u; I
  ( g5 j! N: F9 G4 I         if(ready!=NULL) /*如就绪队列不空*/
  
  6 K8 d+ E8 h# m1 F2 A, N1 {, t
• 
  5 d* f3 i. ]2 V$ J# ^
  * j- u( }* u9 P( f2 @" N7 I" \+ f         {  
  $ R- m- r) P( l/ @
  0 m0 Z: O& Z5 {$ |, _
• 
  
              firstin(); /*将就绪对列的第一个进程投入运行*/  
  , _) O/ j3 d1 y8 x
  ' [$ U* z: i: _0 t7 v; K  I6 Q
• 
  
  ; ]) W3 M3 S- B. H( J4 e' [1 k         }
  
  
• 
  
    @/ Q- F6 i+ t% j      }  
  : d2 o3 W) Y7 z8 {  a- K, Y" J% ]4 K
  
• 
  
  5 {& Z$ t# m, z4 }  m! P9 g' ~+ Q; W      else /*没有运行完同时优先数不是最大，则将其变为就绪态插入到就绪队列*/  
  
  
• 
  
  ( S: F+ z6 y/ |  @: l     if((ready!=NULL)&&(run->prio<ready->prio))  
  + O- I3 ]# L5 |% j
  
• 
  / ]3 \3 J* j" s) N1 r4 A, `3 ]
  ! [5 T: B2 E8 S# m; [) H     {  
  4 p% V/ Z/ x- b. h( P7 I
  
• 
  
          run->state='W';  
  
  7 T( a* q" b4 d6 z/ w! ^# a) J
• 
  - h# Q+ B' ~8 p. \) Q% L9 e+ y1 k
          insert1(run);  
  
  
• 
  
  / _/ {& K& Q9 V5 Q% M        firstin(); /*将就绪队列的第一个进程投入运行*/  
  
  ; a: ~# E% x. T! o( C, M+ i
• 
  
  9 L- m* {1 S/ f6 `& T* k     }  
  
  # {7 N* P' @- V- K5 h7 E+ h  Z
• 
  ' W0 S& I# d2 M8 J( R
        prt(alg); /*输出进程PCB信息*/  
  
  " I! r6 I9 C6 i* d  O7 E5 J' W
• 
  
  1 `' R4 ?* M6 G1 k2 d, B; ~1 q+ n   }  
  ' J% \6 A, [+ P
  ( }, }; u4 R0 t8 B# X! c4 j9 |. L  a4 v2 h
• 
  
  & F! B: K, K0 [& Q5 Y! K3 w+ m}  
  
  ( P* q7 ]* A) l" V
• 
  2 \  P3 |/ M# N
  * V0 W  B& u5 D& h3 M  v/*主函数*/  
  
  
• 
  . ]  w0 E4 w. z0 U2 M2 y" K
  9 y) J; }- o; I" i' `main()  
  
  
• 
  
  + _5 d* u- m- b) I( B{  
  
  2 P/ U8 n& k' O$ v
• 
  & o) `5 j, p: m4 j7 X% {
     char algo;  /*算法标记*/  
  
  ( A. U% q0 K5 Y: @
• 
  
     printf("输入P确定算法：优先数算法\n");  
  
  
• 
  $ V/ I( v) i& E% L# h2 V) a, N
  $ d/ s7 v4 J3 h& C   scanf("%c",&algo); /*输入字符确定算法*/  
  
  
• 
  9 }3 U: r# e% Q
     printf("输入进程数：\n");  
  
  9 ~- u2 A, ~* X  E9 k% M  P7 \
• 
  : p; S, u  p( b  |; T2 w/ F
  6 {  }6 B1 W' k* f1 B  ?( Z   scanf("%d",&N); /*输入进程数*/  
  
  % `1 V: d9 ]" W3 i1 v5 [
• 
  / ^; D5 F' ~& i+ A+ Q% u4 _  n
     if(algo=='P'||algo=='p')  
  ) Q  L' z0 B' S$ e3 V
  : r) K+ Z- D8 P& P
• 
  ) C8 T8 u7 G/ i# |0 v6 z
     {  
  
  
• 
  3 O9 b8 ]& `6 j9 k
  " X% V, W/ N- x7 `      create(algo); /*优先数法*/  
  
  
• 
  ' V7 m5 A7 V; C
  8 \6 \, e  m8 `+ X& h7 c5 Y0 e7 ]& }      priority(algo);  
  
  / Y/ ~+ b! h( c" B- L# r
• 
  
     }
  
  
• 
  
  }
  
  3 P% \! F$ @7 w+ S* s
  8 X9 \4 _- u+ M& u' G' s$ F

$ q* D. n" Y7 Z( ^7 d输出结果：
3 l' g& F8 @, |8 E: J

原文：https://blog.csdn.net/weixin_40962955/article/details/80072769

* N5 ]! b5 [( J) H: e# Y" @
* \+ ?  F; u2 O! ~3 _5 g" |