优先级调度算法

杨利霞

, U5 h6 [' c  {$ _) |% M优先级调度算法
  x1 J5 ?" z' s; z) I- {- G

算法介绍
# Q% g" Y4 J% }9 _& d1 C! h& P优先调度算法的类型（用于作业调度）
9 d9 m8 e. Q6 A4 V  h0 y/ D1）非抢占式优先权调度算法
系统一旦把处理机分配给优先权最高的进程后，便一直执行下去，至完成。
2）抢占式优先权调度算法
只要系统中出现一个新的就绪进程，就进行优先权比较 。若出现优先权更高的进程，则立即停止当前执行，并将处理机分配给新到的优先权最高的进程。

优先权类型
, \, b& E& E* }1）静态优先权
% F4 P3 U" d6 ^$ W' z静态优先权在创建进程时确定，且在进程的整个运行期间保持不变。

2）动态优先权
# Z( V' N) z, u; n' |! ~# ]

算法实现

抢占式动态优先权：

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

• 
  
  ' Z# L* Q  ?3 [; j! I5 A#include <stdio.h>
  
  
• 
  
  #include <stdlib.h>  
  + }# B7 G& a% A- t5 P; e% n
  5 [% E6 Z' d# f* u9 h* P2 \
• 
  1 G+ a7 L; C; T/ x$ J- B
  % H  y+ s9 q7 @5 ]#include <string.h>  
  8 v/ ]; R: ~7 w$ [( L  W/ {+ U
  
• 
  
  ' P+ y: `1 N: K) k% [8 }/ \typedef struct node  
  - q9 K8 v: ^  ^. T
  5 B6 o% W! a7 V. u' w8 q% r) U* o$ X
• 
  
  {  
  1 N) d$ v  i& ?* W, B
  
• 
  
  . k/ q8 F* C9 J) Z   char name[10];  /*进程标识符*/  
  0 h$ _, H& x) F1 F7 k1 R
  
• 
  
  : l2 h' n" A  O- i& J, F6 E   int prio;   /*进程优先数*/  
  ( Q& @& H7 b& r, Z' Z( Q0 n# e# J/ G
  6 o7 l! Q0 y3 }; R. Q
• 
  
     int round;  /*进程时间轮转时间片*/  
  
  
• 
  
     int cputime; /*进程占用CPU时间*/  
  
  
• 
  , s- d- J, C: v+ j$ R
     int needtime; /*进程到完成还要的时间*/  
  0 n5 c* \0 g+ O5 T: U
  
• 
  
  $ v1 J, X( k- f  C& W5 ]   int count;  /*计数器*/  
  
  & @% {& ~7 J: s$ Y8 t
• 
  0 }' R# l/ ?( o5 L5 `7 k/ _; d
  0 [7 ^) k( K3 g   char state; /*进程的状态*/  
  ; J5 C* W" u9 [" p. _7 `$ ?
  
• 
  
     struct node *next; /*链指针*/  
  
  
• 
  3 n$ S8 V. V8 x8 }5 i2 o+ P
  . A, I, P! m' n}PCB;  
  
  
• 
  / G0 A9 \" B0 R
  PCB *finish,*ready,*tail,*run; /*队列指针*/  
  
  3 D% J0 k+ p, _( v1 E+ j
• 
  9 `0 {6 Q" ^& d+ H9 B* b7 E# r
  int N; /*进程数*/  
  ' x5 Y& O3 {  r7 A1 \1 E! e
  / X2 V: w" x0 z3 _" Z
• 
  # W& f3 v) A' {
  % X3 G- g1 m. I- @' D/*将就绪队列中的第一个进程投入运行*/  
  
  : q4 F+ P+ ?! o) D
• 
  
  / G3 @1 B& Q- O3 ]. E( X, afirstin()  
  
  7 V; w4 `2 P: ~! J' e2 b
• 
  . Q, L( J; |, v) r& f
  {  
  * g1 Q! \+ `$ b
  
• 
  
  4 d% ^2 O2 G1 C# W% ?: D- s9 ?   run=ready;   /*就绪队列头指针赋值给运行头指针*/  
  
  + S& j5 ]+ u9 C' _; b0 g
• 
  
     run->state='R';   /*进程状态变为运行态*/  
  
  1 p4 d& X. l0 B. m* b9 Q5 S
• 
  
  ; }% f( y9 q4 `3 e  h( @   ready=ready->next;  /*就绪对列头指针后移到下一进程*/  
  ' [" e+ A( s3 S
  
• 
  " C2 p/ D! F' |7 w
  5 o7 G, g0 q* p9 Z4 s4 J4 Y}  
  
  2 E  z% n! p8 N- X+ v. C
• 
  4 V% l- D9 m: {  F
  /*标题输出函数*/  
  0 A, M$ w9 U# u* V- }0 T1 v
  
• 
  
  2 T/ F; ?" \4 y; Pvoid prt1(char a)  
  2 e% ^6 z8 I$ l- q
  
• 
  , ]$ g$ P/ G5 `/ i. g
  {  
  " g/ @# R, \- A0 E5 H8 e
  
• 
  5 Y# j: h- c/ |# p8 N
     if(toupper(a)=='P') /*优先数法*/  
  
  # O# r! k" s# N$ p( Z
• 
  , F% P1 m/ f2 ~) B  a& m' ]# i
  * E3 ~7 R. |" k' S6 W: }6 Z3 N/ a      printf("  进程号   cpu时间  所需时间  优先数    状态\n");  
  
  3 _9 M& t" U% F
• 
  : v# ^8 @$ i3 d4 {5 d
  / B8 P/ N# K) s: ?/ Z   else  
  
  * {6 j% p/ h! @. ?
• 
  
        printf("  进程号   cpu时间  所需时间   记数   时间片       状态\n");  
  
  - _9 {+ G% w+ s/ D! r1 Y
• 
  $ |9 l6 R& D0 B) l. f5 F* T8 u
  $ I; \: I; ^, c' Q8 S  S}  
  
  , ]. A; N8 F" D" H
• 
  7 U% x# f4 I5 W+ |/ H
  . b: A* f  R- B" x/*进程PCB输出*/  
  
  
• 
  
  void prt2(char a,PCB *q)  
  ( s. ?1 H' @% _( @
  
• 
  
  {  
  
  7 _0 n# g- L: X3 u! x6 `1 ^
• 
  
  4 u6 G% c& a: _& J9 K; g1 l   if(toupper(a)=='P')  /*优先数法的输出*/  
  ' N) ^; o# ]5 T& _' P! B
  ; o, b0 w6 z1 U
• 
  % p2 Z  l% U; F2 W* G( I3 s  B0 r
  7 P5 f! _: {, U+ [( e; E  k$ I      printf("  %-10s%-10d%-10d%-10d %c\n",q->name,  
  
  
• 
  
         q->cputime,q->needtime,q->prio,q->state);  
  
  
• 
    D. r9 z; ~/ ?9 D
  ) G; @  w$ D+ O$ }/ v6 h4 Y4 i8 M2 @   else/*轮转法的输出*/  
  
  
• 
  
        printf("  %-10s%-10d%-10d%-10d%-10d %-c\n",q->name,  
  1 c- }# M3 j+ M, N0 F+ l: b
  + y1 w' W( D+ d" a4 [
• 
    l. ?; G( \+ Z" a& k
         q->cputime,q->needtime,q->count,q->round,q->state);  
  - I( C. F1 T- }, U  z
  ( o5 o. s0 |/ o% p4 j# [
• 
  5 p& F+ T; X7 H( h+ W
  ! `! r" t4 P! v# Y2 r: \}  
  
  % z" r- N( {5 |# y3 o8 T
• 
  
  /*输出函数*/  
  
  
• 
  
    @2 A9 z: k2 r, v  j7 O& h% hvoid prt(char algo)  
  
  8 p1 V0 \2 j8 m% J
• 
  / i1 a2 |) Z3 R& x7 _
  8 i9 u4 F+ {+ ?2 [& q  g{  
  
  
• 
  
     PCB *p;  
  3 y& J3 G' k  m# S
  
• 
  " B9 H9 X$ t3 G% n/ o
  9 [& b& M% [( y# _8 n" q) b) P   prt1(algo);  /*输出标题*/  
  
  
• 
  5 E$ k  g! i8 i
     if(run!=NULL) /*如果运行指针不空*/  
  . i% i' r+ k  f! ~
  
• 
  
  2 `5 |/ W+ ~2 y3 j' ~: M* [      prt2(algo,run); /*输出当前正在运行的PCB*/  
  
  
• 
  
  * u" j3 m" {1 p5 v  ^2 M   p=ready;  /*输出就绪队列PCB*/  
  
  
• 
  
  ' I# ~( j2 P# b5 o/ H: `   while(p!=NULL)  
  
  
• 
  
  7 `0 S2 v! ]# |9 m3 ~5 ^   {  
  9 ~. [/ T" V/ n  x5 U
  6 K& Z! [4 J/ O8 x3 H
• 
  
        prt2(algo,p);  
    F* m3 O: V& [: S# E  ^; S# w
  
• 
  9 V4 Y7 @& D# Q$ w
        p=p->next;  
  0 E# G/ \/ g6 F- J- h) u6 n
  7 D0 a0 x( S# i. T& I
• 
  
  4 l5 ]* B& `+ h# W- ~   }  
  ' |! M* _; p8 Q: d+ V: H
  
• 
  0 g7 O; K4 \0 v4 E
     p=finish;  /*输出完成队列的PCB*/  
  
  
• 
  
  + w; r: v  k. b8 A0 m+ f7 G   while(p!=NULL)  
  
  & e' P" A7 s6 O* `8 Z" y/ _
• 
  
  , m  a; n" `) |0 q5 E   {  
  
  & d8 Z" W9 z( p9 v
• 
  
  5 H5 w9 n! q9 N4 a: p1 W      prt2(algo,p);  
  ) D+ t: K6 l' C" H
  
• 
  
  ' N" z5 A# @+ S; [3 P& T0 r& }3 k      p=p->next;  
  
  
• 
    @8 U6 Y2 W8 p5 Z5 {- w9 C  f
     }  
  0 z/ X# }* f$ t4 ~, p
  & k. Y+ v0 ^7 E2 f$ R  q5 O+ E
• 
  
  ) `1 F" _/ o& i3 j, d* c   getchar();  /*压任意键继续*/  
  * i& S1 [2 [" }2 L
  2 l5 z0 q6 k; c0 [- `1 B
• 
  
  & O" {+ _3 A$ i+ j( F}  
  
  , U! w! _  F) y# V0 u: }
• 
  . b* q7 s4 w( `# R4 |5 ^! N' w
  /*优先数的插入算法*/  
  
  
• 
  
  1 n+ H# ?$ m% ]2 _insert1(PCB *q)  
  
  
• 
  
  ' ]% m, h) S7 l/ }{  
  ( K3 J6 f2 Z" a4 e0 n
  , r( _2 V% H" K6 U, j
• 
  % R9 p5 q* R% T0 C4 S
     PCB *p1,*s,*r;  
  % S8 Y8 h. `: O& I; z  D
  
• 
  
  9 y! m6 `' v& {: L* b$ L1 x   int b;  
  6 n4 x4 M7 ?5 N/ ~/ T0 \/ j, z7 N( J/ b
  
• 
  % m( d* m$ \# Z# C- c' v% ~
     s=q;  /*待插入的PCB指针*/  
  
  
• 
  
  2 D8 `5 }: Y; Z+ T/ b0 b; H   p1=ready; /*就绪队列头指针*/  
  ' }! Z' s1 \! X) ?/ P
  
• 
  , I" k* r* x/ i- j8 W  g3 e! u
  : i( o; f" I" {) A1 \   r=p1; /*r做p1的前驱指针*/  
  
  . f0 `0 |4 `) f) @
• 
  
     b=1;  
  ) I8 ?$ M$ h7 w6 _9 i
  6 g% E$ o) P) T* h
• 
  , c6 ?; ~3 Y/ I" p% d  e# C
     while((p1!=NULL)&&b)  /*根据优先数确定插入位置*/  
  2 Y/ Z6 k4 a) l$ Y9 G
  
• 
  
  : ?, Z! R! \  F7 @* H5 {3 h% p# ?      if(p1->prio>=s->prio)  
  - i: ^/ v! x6 }: L  ?
  ! }" a# s" S: h
• 
  
  3 n" H: Z1 b1 v9 O) D/ V      {  
  
  
• 
  
  8 m, J" Z0 L9 n7 E7 v$ y     r=p1;  
  
  
• 
  
  7 c8 _" e9 W+ a8 D, }! {- w" m8 G     p1=p1->next;  
  
  
• 
    j# O- y( p. ^4 H, \: R0 S& B( h
        }  
  ' m2 J/ |; d' Q- X
  9 ]& C' c2 a5 D
• 
  
        else  
  
  
• 
  
  0 ]' c/ r' \+ m' n3 d     b=0;  
  5 f; Z. Z$ r8 U8 F, X3 _
  
• 
  
     if(r!=p1)  /*如果条件成立说明插入在r与p1之间*/  
  
  ; h$ g8 L4 }4 V  P  W
• 
  
  0 h5 a% e- C, t1 n2 m   {  
  6 U! w- r& Q* Q4 ~! X
  
• 
  
        r->next=s;  
  9 a0 V" A  g4 W' q- w) ~
  : ~+ R- [% g3 n. |/ W# G& W
• 
  
  - T  a# u  x2 G# g. Z. d      s->next=p1;  
  2 z4 R6 Q4 f. h7 V$ M
  
• 
  
  3 z/ V& @& [% k5 |; A; A   }  
  
  ( G- s  N$ K0 S. p5 [0 S6 f
• 
  
  ( y1 h7 e1 g. Z" ]$ z* a$ D- i   else  
  
  
• 
  
    e' Z2 u8 K/ I   {  
  % F3 @& o$ v8 M# x2 i" S' x3 C
  * \3 Q% S( \5 b8 y9 h$ P# z
• 
  * i: T7 v$ T2 E4 [0 C6 i  l
        s->next=p1;  /*否则插入在就绪队列的头*/  
  ( [- F$ M/ X$ X
  
• 
  
  0 _7 b) }# e. p6 i      ready=s;  
  
  , n3 _( e0 Z# X0 l8 O  ~+ g
• 
  4 q9 p* a3 H( G- I3 z5 D  A
     }  
  - Q& y) Q6 W- {
  
• 
  4 X0 N) I) |) P
  }  
  
  - d5 z$ J% Y; e6 @
• 
  : h6 S* S! u: p' |0 R8 Y. ?1 r) M
  $ n6 u+ L4 `# ]* }6 D9 m! W3 o$ o/*优先数创建初始PCB信息*/  
  / x! C0 s* P- B
  
• 
    ]! a1 Y  b" I  s0 ~) o
  5 i% e& u& k/ Nvoid create(char alg)  
  
  & t& ^( P- a: H
• 
  ; U7 ~. l1 p: U1 o! T) ]+ R' J+ V
  ' y3 T- ~3 Z" E+ o) D# P( \{  
  
  
• 
  % K7 k5 l) R0 a% d
  $ |5 o, [7 |$ Y2 G' W) S( \% w# c2 O4 [   PCB *p;  
  
  3 X- A+ ~5 x( u
• 
  4 U5 G. R. r6 Y1 D5 w" q7 K  b( j
  5 Z! f- n! L5 V3 p/ a' }. ~) U   int i,time;  
  
  - w" M( g4 |7 T# |% r& m# x3 o
• 
  5 @, S' `% j" N# U5 w3 f/ Y
  % ~5 \5 I; H) {- S- {% T) r   char na[10];  
  
  
• 
  
     ready=NULL; /*就绪队列头指针*/  
  6 M1 B9 d+ s& b; o
  ' z8 T, @9 }' f8 S
• 
  
  0 {! ?' k7 W/ _8 C   finish=NULL;  /*完成队列头指针*/  
  & C$ b$ f0 z0 r) \1 }; k
  4 |2 \& J5 S1 b2 K0 m, r$ K: Z
• 
  * q- H6 I, z$ P. r9 x# [1 o7 F. r# w5 N
  % F( U% P# r4 ~. w! Z! u; M   run=NULL; /*运行队列指针*/  
  $ _0 @# m+ F5 @6 \3 M& H
  
• 
  - X' ^# S8 g8 w/ i. u+ o' o# s
  % l# V  P- k3 H: Q% c5 |8 [, }   printf("输入进程号和运行时间：\n"); /*输入进程标识和所需时间创建PCB*/  
  
  
• 
  9 `& G7 T4 j* ^+ P
     for(i=1;i<=N;i++)  
  
  # N% Y4 s4 a4 O) j- f. I. T
• 
  
     {  
  
  , q, g. ^  |5 n' Q9 L
• 
  
  ) D0 m7 n# a% J( J# R      p=(PCB *)malloc(sizeof(PCB));  
  ) ?1 ^, |! H' B/ i; t% M
  
• 
  & A" B+ O. h+ O5 K& {" c8 n) a
        scanf("%s",na);  
  
  8 s3 [5 ~- O# j% T! a
• 
  * Z$ ]& \3 z! I: O, M
        scanf("%d",&time);  
  
  
• 
  2 p* W8 D2 f7 S" J7 h" q/ }( t3 |
        strcpy(p->name,na);  
  7 X' g+ u6 G( s/ n
  2 Y. I5 }' D, @
• 
  7 y$ r2 V6 v  {7 B0 S
        p->cputime=0;  
  
  0 I3 ~# c% ^- ?2 J) y
• 
  9 [5 ^2 V7 E2 c9 Y5 q3 A
        p->needtime=time;  
  
  $ R8 b. p. W; t& j
• 
  
  + M6 U/ B" E& @2 D" E- C- B      p->state='w';  
  
  
• 
  # `& }) S" u' _# r( H* _3 i
  + x# ]  m! u) Z, V7 I, T+ \      p->prio=50-time;  
    H. p$ r1 I& f3 a4 P
  
• 
  & Z9 ~  h2 l+ b  i# r- ^4 a
        if(ready!=NULL) /*就绪队列不空调用插入函数插入*/  
    ?0 b' A; t. G. P" Q' z; ]. i
  
• 
  
       insert1(p);  
  
  , m2 s( m7 w' k# H  j# K3 T
• 
  
        else  
  
  
• 
  
  1 b3 m8 w0 V0 I( G3 T      {  
  
  1 p; E7 p" s0 |$ C, U2 L: D7 _
• 
  
       p->next=ready; /*创建就绪队列的第一个PCB*/  
  + M5 F" z3 _: F! x2 Q* L% Y1 Y  f! M
  * {( q& I, C3 \, O, b
• 
  
       ready=p;  
  
  
• 
  6 G4 ]. b, \) u1 U; Q9 V7 w' E
  ' Y! W% R1 |; J* x" Z) j      }  
  . j- e" g2 A% B, r: X
  6 D+ r6 T& j. z6 u0 f% f
• 
  
     }  
  + ]4 K9 }& c! W, U0 J( f
  
• 
  
  ' W3 a/ k# [) K# }4 R, g   printf("          优先数算法输出信息:\n");  
  " K4 P* L1 y4 E2 a, h+ c
  , a& A- P+ k: }/ f; l4 `
• 
  ! v" W+ f5 s. H9 |$ ~
  - V1 T: Z& N2 b$ ]1 r, C3 s. c   printf("************************************************\n");  
  
  ) T% N6 o1 [( r* r8 ?: X
• 
  
  3 R* y4 ]& y5 U  l, G( y# {   prt(alg);  /*输出进程PCB信息*/  
  
  
• 
  
  & r$ W$ r$ Y4 V   run=ready; /*将就绪队列的第一个进程投入运行*/  
  1 j$ {" @% r( r; t2 X% V5 l& [4 V
  3 {1 Z$ w; f4 ~( s' ?3 j3 w
• 
  
     ready=ready->next;  
  
  
• 
    l7 q% {4 |) ]  b7 n
     run->state='R';  
  " c, C8 N7 e2 J  i% @  v1 \* w
  8 e3 f7 D& x5 [2 }! V+ s( C
• 
  
  5 ]' U: o$ [2 I2 y+ q7 s}  
  6 N' a8 b( g; H* W& |# @
  
• 
  7 ]0 e0 Y: i) m% O# D! f8 o9 X& w
  8 c9 y. @% n- J/ k- b2 v/*优先数调度算法*/  
  & a  S% X7 ^: R. i. k
  
• 
  # W3 l- p6 }5 R3 V/ S# E
  : {5 Y( ?( a* d- N" Upriority(char alg)  
  
  3 S# a" A; H7 O  y' P9 X
• 
  % o9 Y- n* {% H% ]
  {  
  
  
• 
  
     while(run!=NULL)  /*当运行队列不空时，有进程正在运行*/  
  0 _) h3 B1 l" G9 [
  
• 
  
     {  
  
  
• 
  
        run->cputime=run->cputime+1;  
  5 y% }. P! I: v" `
  0 g5 l  h3 K6 g9 O6 u
• 
  ) h4 h- c5 U+ w# z" W
  7 w1 q+ ?4 M; |  V8 X7 a      run->needtime=run->needtime-1;  
  
  
• 
  + c3 a% }8 B9 j7 F. ?" f
  ( Z' g' M' e7 V0 w5 ~      run->prio=run->prio-3; /*每运行一次优先数降低3个单位*/  
  
  7 l. e$ b; U- O* x) A# g
• 
  ; w4 o& h* E) t, w" Y
  7 ^, f5 i; u, Z  R      PCB *p;
  
  
• 
  
        p=ready;
  
  - X3 |1 l1 D4 H
• 
  6 l; v6 n5 J; k# x, d8 d8 {
        while(p!=NULL)  
  3 ~) K3 v# ^# n& W. `3 F; H; u
  , R$ k% `% l4 P- \. Y6 r8 l; D9 P: c
• 
  
        {  
  : X: J+ r+ A+ @6 O1 T
  
• 
  
            p->prio=p->prio+1; /*每等待一次优先数升高1个单位*/   
  
  
• 
  
  & I# o# k; e7 H          p=p->next;  
  
  0 s. y1 t* f! a/ P
• 
  : L1 j( T, V9 e1 O( D! u; P! ]$ c8 ~* A
  / ~! c* C1 L0 _2 z      }  
  
  
• 
  0 G6 u, k. c( K" F( |9 p% }
        if(run->needtime==0)  /*如所需时间为0将其插入完成队列*/  
  / X/ A! M7 Z) O. o/ Y2 G
  ( W" [5 q2 X# e! X( K! r
• 
  
        {  
  ; T, ^' p5 M4 o/ B" T
  
• 
  8 o3 q1 R( R; L6 z1 D2 [. d
           run->next=finish;  
  , r6 Z' s; `) e2 ?1 u- F, K9 i9 e7 e
  
• 
  
  : v& G( z8 U+ j2 f1 J( z         finish=run;  
  
  $ r" t3 t4 a2 `6 t/ i: D
• 
  & _1 R. V4 k  V
           run->state='F';  /*置状态为完成态*/  
  
  
• 
  ! _) f2 ~8 R% e5 @* n. A/ _
  * C- E& a+ q% n         run=NULL;  /*运行队列头指针为空*/  
  
  * ?# Z5 d& |% Z) e
• 
  
  # g5 ]* |! n9 |( x         if(ready!=NULL) /*如就绪队列不空*/
  
  
• 
  
  ) |$ h5 r' }3 Q1 ?- |         {  
  / [$ R( ?9 ~# B2 T3 Y2 g
  
• 
  
              firstin(); /*将就绪对列的第一个进程投入运行*/  
  , T# s; ]4 I: Q( n) N
  
• 
  ! i4 B% S) R) K' p- E1 |0 H" \; i
  . g! o# H% ^4 w" V/ h         }
  
  
• 
  
  . P/ L* E, R% k      }  
  & g2 ?- s0 W. H6 F' m  c
  
• 
  
        else /*没有运行完同时优先数不是最大，则将其变为就绪态插入到就绪队列*/  
  
  
• 
  & r2 U- i2 }* \- y$ i2 Y& A
  6 l* u% y  U" T2 P$ W     if((ready!=NULL)&&(run->prio<ready->prio))  
  
  
• 
  
  & p7 D3 V. R! e: u1 Y: b     {  
  5 _! b. U) V( t) G% f
  * D8 r7 s. @2 e9 f! A
• 
  2 q' t5 o0 s2 V. g) n: ^
          run->state='W';  
  " G% q' i6 v. X9 `6 ?$ d8 p
  
• 
  
          insert1(run);  
  
  
• 
  5 y& C! j# g7 I7 L" |
  9 y8 a% p; v" B- d0 F% v        firstin(); /*将就绪队列的第一个进程投入运行*/  
  
  
• 
  
       }  
  
  
• 
  2 Z; R, Z8 I' K
        prt(alg); /*输出进程PCB信息*/  
  
  
• 
  % k! O( R# ?/ A( m% d9 X
     }  
  " e' t* v* `1 m5 J1 ^& D% g
  $ r# f# i' `+ o' }: a* t2 W
• 
  9 Y% d! _) c  d$ e. O9 i6 H; s
  }  
  
  
• 
  . f! F. D7 @5 u
  /*主函数*/  
  
  
• 
  
  main()  
  ; a  [8 [( ~" t5 g( b' g+ Q
  
• 
  
  5 |+ w8 _9 \& c- m. P" z{  
  9 [0 m7 E4 D2 C& t, z* S$ F3 {. q
  " V. ?; [+ T8 O- I) M
• 
  
  7 E1 L0 c* g" L; x: ~+ Y! s   char algo;  /*算法标记*/  
  
  
• 
  " c) x3 G7 P: j, }, ^. i
  8 y' J) j) B5 B5 C+ t1 P9 j. U+ ~   printf("输入P确定算法：优先数算法\n");  
  
  6 x" z+ t  i) y' D
• 
  6 }! {) U" {' V
  " t+ j+ W) }$ K& ^; m9 }   scanf("%c",&algo); /*输入字符确定算法*/  
  
  
• 
  & u0 k+ H- X6 t4 [' z# N" E' O4 I
  ; h' N+ s: l  K   printf("输入进程数：\n");  
  : `) \( C+ p: @' H: a( R
  & C: E- P9 \8 }1 n
• 
  
  : i% T5 q  f6 C" b   scanf("%d",&N); /*输入进程数*/  
  ; _# E- C4 c0 ?& D7 z0 Q
  
• 
  . F. N# I6 r& q. K* g
     if(algo=='P'||algo=='p')  
  
  , G3 O0 ^# B+ ^, t0 \* A
• 
  ! `$ }+ l  o6 V9 b' r8 {  K
     {  
  
  
• 
  
        create(algo); /*优先数法*/  
  9 l" \8 U! z* R% ~
  
• 
  % Y& l% `% }" ~3 f- t# B/ B7 |& @
        priority(algo);  
  
  # |) e+ X5 N1 d+ e  ?
• 
  ; O4 w9 W, p; Z
  & r; ?, B- g. k, b/ k' V' G; p: `: i   }
  / v( p. R6 O* a# l
  
• 
  
  3 E2 X7 v( r) w# W# K* U}
  
  + K$ ~" S! ~9 ^& y
  

) g4 j% N5 G% F5 a输出结果：
, g- w& V$ F# I

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

- s& Q+ G% d6 [8 I7 A1 Q