优先级调度算法

杨利霞

+ a" q$ V8 E+ D3 r/ B优先级调度算法

算法介绍
. Q  t; y& q- P* O1 L  t优先调度算法的类型（用于作业调度）
* q9 {/ ]# L' r$ I& J4 j1）非抢占式优先权调度算法
( x" z5 M) ^& y系统一旦把处理机分配给优先权最高的进程后，便一直执行下去，至完成。
( S' C( D* q2 P( p( ]- C2 K% a2）抢占式优先权调度算法
只要系统中出现一个新的就绪进程，就进行优先权比较 。若出现优先权更高的进程，则立即停止当前执行，并将处理机分配给新到的优先权最高的进程。

优先权类型
1）静态优先权
, Z( M: }& ], B1 n" |( |, x静态优先权在创建进程时确定，且在进程的整个运行期间保持不变。
' z! O, I" y  Q* n* A% O6 }

2）动态优先权

算法实现

抢占式动态优先权：

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

• 
  6 \( q# R. @) P8 k- r
  & R. C( Y$ j8 }+ v! f3 n#include <stdio.h>
  
  & c6 }6 b" ~5 T
• 
  
  #include <stdlib.h>  
  : I3 j+ E5 x6 I
  5 s, _/ S( q) {( G- S
• 
  
  #include <string.h>  
  
  
• 
  
  9 J" l0 ^( b9 P7 Ttypedef struct node  
  ) Q4 c0 O( w' C! p- p0 n4 m
  
• 
  ( _. a- v8 W  w9 H
  {  
  
  ; v& D7 U: r+ T  H) m
• 
  6 R: e, W3 C3 B1 s  o
  3 x) M) T- V9 y  ^9 }' M8 k% u   char name[10];  /*进程标识符*/  
  1 l- l3 h- g9 |% U! W# e- A
  
• 
  # ?: w- B+ d3 _% c( @0 `/ _3 M" f' B* }% v/ @
  5 X/ ^0 b1 b% {8 b, z. M6 P   int prio;   /*进程优先数*/  
  ) T8 r* u1 N, x3 C9 ^
  9 F+ _5 E$ r- ^( ~0 Q5 y; b
• 
  
  , W7 S9 x, R9 G   int round;  /*进程时间轮转时间片*/  
  * h6 V5 F( r4 C
  
• 
  
  7 u  j4 W0 f# b# D! l6 F   int cputime; /*进程占用CPU时间*/  
  ; x" Z$ w( q& L5 T6 I$ N. a
  ) `+ q7 l' N: u6 n& H
• 
  
     int needtime; /*进程到完成还要的时间*/  
  
  , X- R4 T% \4 Q6 }- T' N
• 
  
     int count;  /*计数器*/  
  % B9 w) m; D5 z9 Y/ b/ E- O
  
• 
  & n. q/ S) F; A* @2 D# G
  - \( H! i+ @' N7 `! N, `   char state; /*进程的状态*/  
  
  
• 
  
  1 u. g( h/ F# K, i   struct node *next; /*链指针*/  
  : q# F# m+ \% l* P4 Y
  
• 
  
  }PCB;  
  # l' X* Z# R; `
  0 Z- ^' L# q# N" ~/ j
• 
  % W4 C; S- v" r0 y
  ! e9 ^+ _; E; i" V: pPCB *finish,*ready,*tail,*run; /*队列指针*/  
  
  " V4 h: a" y7 T# G0 `4 c! x9 u
• 
  . z' L. k& b$ m! d  U
  int N; /*进程数*/  
  
  
• 
  
  * {; V/ {. S/ `0 b: ]: E/*将就绪队列中的第一个进程投入运行*/  
  
  ; @' i! Z  l5 n' w7 g# S
• 
  
  * L! ]: J* o% ^* G5 I9 d4 pfirstin()  
  * \5 E$ ~9 j& c  O  a- c
  ( a- I: Y+ }, Y; e4 S- N) x7 C2 G
• 
  ; q4 S, z) w5 q; a/ T- k( t
  {  
  7 d; O8 X4 _$ T( b) @" j, o
  6 _. q5 P1 \: A8 L$ x+ s. V8 [
• 
  
     run=ready;   /*就绪队列头指针赋值给运行头指针*/  
  
  9 |# H- E$ {: F$ t7 b9 O, o
• 
  , M' d, Q% F6 W+ J/ @2 l% n
  6 k& P1 _$ i/ a- s9 |   run->state='R';   /*进程状态变为运行态*/  
  
  & L/ H1 l4 N. I
• 
  # v; b" a) j0 {5 _
  9 F* W7 I# j7 o. b" B$ r   ready=ready->next;  /*就绪对列头指针后移到下一进程*/  
  0 I7 T  ?' U) |/ }2 m
    A) c' t. o8 Q
• 
  
  }  
  ( H0 ]) E( B0 u" E
  
• 
  - L' N2 c- C6 g
  /*标题输出函数*/  
  
  3 Q# n" C: Q) O) g7 d
• 
  3 j+ f- |( Q( Y# }
  void prt1(char a)  
  
  : V  u, N  e4 I" L% w
• 
  
  ! p( x& I0 \# f3 G, b+ Q{  
  
  
• 
  
     if(toupper(a)=='P') /*优先数法*/  
  / ], L3 T6 d! k# O9 T0 ^
  
• 
  6 d2 l, `# A' X
  + B9 m$ |* u9 i      printf("  进程号   cpu时间  所需时间  优先数    状态\n");  
  
  
• 
  7 D8 v; ]6 z0 i; V
  1 q2 N& t: O) j4 j5 K! w   else  
  
  3 d) n5 T* d- A9 F
• 
  
        printf("  进程号   cpu时间  所需时间   记数   时间片       状态\n");  
  : I# P+ c/ h! Y6 K" G7 \) Q
  + L; W/ q8 M* f6 [% n" b! T8 L
• 
  : Q3 c: s! Y6 N5 A% a, R) a8 ]
  . j* |0 T/ B# S! a}  
  
  
• 
  
  /*进程PCB输出*/  
  ; l% ?' U  N- M0 d1 n3 H7 U4 A
  
• 
  
  void prt2(char a,PCB *q)  
  
  
• 
  1 p' {  d5 s/ h1 p$ P4 F2 j7 e
    e5 w, y- h" E% g4 w" B4 v{  
  ' g& i( e7 W6 X* e+ ]8 M
  ) O0 Q" m% N" N' l) T4 u
• 
  / T. V+ L& t( W! W! p1 {* T
  6 w( Y' L1 V# y   if(toupper(a)=='P')  /*优先数法的输出*/  
  / u* z  X: E2 [% j! Q
  - c; }+ I: v" ~% K( n) l$ n
• 
  
        printf("  %-10s%-10d%-10d%-10d %c\n",q->name,  
  
  
• 
  / U7 M4 n' M" [7 S5 o8 {
  ( _/ s1 r8 @6 b3 e% Q- ?0 c       q->cputime,q->needtime,q->prio,q->state);  
  
  . @& n) X2 F& i+ q) ~% o% {
• 
  $ v, b5 d) Q: i# [+ Q" ~1 C
     else/*轮转法的输出*/  
  $ y1 T+ I: v9 J/ h% {7 [9 {
  
• 
  
        printf("  %-10s%-10d%-10d%-10d%-10d %-c\n",q->name,  
  4 t7 N3 s% |4 w- l5 P
  
• 
  
  7 J% |* S- O0 c+ B. }( |/ c       q->cputime,q->needtime,q->count,q->round,q->state);  
  
  9 w) t# K7 X& q& b; Z8 Z
• 
  
  }  
  
  
• 
  
  1 S) r+ }4 h: O5 n3 ]# |/*输出函数*/  
  3 |. S1 p- ?8 c2 ^; ?+ T
  
• 
  
  4 Y! u4 p; }& _& V3 X7 Qvoid prt(char algo)  
  
  $ S8 ~) o# S: C' G! G" W4 z
• 
  
  {  
  : G* G) H# z1 g9 V( _
  8 i& Z- R: b, G7 a1 k
• 
  % a( u( q" l3 S* K* @0 P  s6 R
     PCB *p;  
  6 `9 K6 P' N2 s1 T, w
    {- }5 f# x  J$ l* T' ~7 Q
• 
  
  ! G+ s, P+ g. V! K, O+ h   prt1(algo);  /*输出标题*/  
  
  
• 
  
     if(run!=NULL) /*如果运行指针不空*/  
  
  / Z4 ]: n" w; @. S3 N
• 
  5 R; E2 c8 C' \
  9 y- d5 h1 _! M* ]3 f7 S+ H      prt2(algo,run); /*输出当前正在运行的PCB*/  
  
  
• 
  
     p=ready;  /*输出就绪队列PCB*/  
  
  
• 
  : T5 B" a8 m! l: j) @  H4 t9 }
  3 Q& D, q6 F  @   while(p!=NULL)  
  / d4 k3 q4 K& @5 {5 s5 C
  ) r- d0 [* F; e. A4 ?! ~0 o
• 
  
     {  
  
  
• 
  / E# G* j( c0 i; q4 Y3 \
        prt2(algo,p);  
  8 [# N& C  c/ T  R) V- w3 W
  
• 
  
        p=p->next;  
  
  
• 
  " W' {8 Z( ?5 _. D7 r' Y1 [
  ; R# D  {4 g  r0 Q0 K( s7 P   }  
  
  4 I! O2 @; B; C7 x6 Z" U3 B
• 
  
  ( s2 E7 Y  O; j   p=finish;  /*输出完成队列的PCB*/  
  * g0 F/ H5 Q. ^+ L% `$ K, l& F
  
• 
  * A6 y* i; Z3 f# l  I: m+ r/ r3 K# E
     while(p!=NULL)  
  
  
• 
  
     {  
  
  
• 
  
        prt2(algo,p);  
    f- c3 E  \+ M. R: ]0 {/ `, S
  
• 
  
  4 l9 P) M3 v" f& v! \      p=p->next;  
  
  $ |4 j  c: q5 X8 }! E+ T
• 
  & {* t  ]$ t5 |
  / u/ ?) Y7 j" B' i   }  
  ! m$ J( O5 A0 j+ Z
  
• 
  9 g- W' ?; u4 l' o* x6 S
     getchar();  /*压任意键继续*/  
  
  7 k! {5 z$ r( A2 I" m2 a
• 
  
  & B5 Z& R* Z8 E}  
  
  - n6 l( t/ R2 {3 K' I7 R) P
• 
  - X- ~' u  G1 ~2 C
  /*优先数的插入算法*/  
  6 j) }# e. l% L5 }: X1 u5 Q
  
• 
  ) z, g1 R6 ^$ B! P2 k) J
  " E! u0 U  ]4 K* x2 Einsert1(PCB *q)  
  
  0 j2 h# j0 c, W* u3 e: v
• 
  
  # t" R- L9 y- o{  
  
  9 a; o# Y: @# R6 s' I( Z
• 
  3 U/ \# a, z3 s+ ]" L& Z
     PCB *p1,*s,*r;  
  ! A% A) F) s4 x
  
• 
  
     int b;  
  , C  h) r2 [5 V. I' o3 Q
  
• 
  & }4 ]  s) U/ C( a
     s=q;  /*待插入的PCB指针*/  
  ! `- o7 G. {6 r
  . W3 d% k0 m  [& |
• 
  
  # \/ C, H' I0 B/ |. D$ |0 T  v0 M   p1=ready; /*就绪队列头指针*/  
  7 ?' _" C) h; ]2 E: c$ l+ O
  
• 
  ' l6 x1 \, n- A% e3 B9 \( `( u
  / Z2 L/ X9 G6 `1 K1 B   r=p1; /*r做p1的前驱指针*/  
  3 ]" d& J# W# z& i! F5 d3 C
  ) N. \% T: z" S' B, X
• 
    G7 H8 b5 @2 x( K
     b=1;  
  
  & }1 g/ t7 q: F9 i3 v
• 
  / `. {% O0 }5 U$ z
  5 a8 X9 y6 ~- ~   while((p1!=NULL)&&b)  /*根据优先数确定插入位置*/  
  # [4 W( I2 y4 e: Q& `
  
• 
  
  ! I* C. Y" S; x$ ^$ D      if(p1->prio>=s->prio)  
  & E7 a6 M+ @3 h0 m7 V) M
  & x# s8 @% c3 ~- M& x0 n6 F
• 
  / U/ B; Z) O* g( w: J/ d
  # T$ `6 Q% K$ |' N+ F0 @) C- g/ x      {  
  
  
• 
  1 J7 e% m' @* }
       r=p1;  
  
  
• 
  
       p1=p1->next;  
  4 R8 \/ z7 o& {3 U5 O2 ]
  : _( x/ ^2 J5 K; K  v3 x4 r+ O
• 
  
  4 N' R1 V" b& B      }  
  
  
• 
  
  $ W$ [1 e; X1 W5 r) D      else  
  " t% {* B5 N0 k1 a
  / M! _0 o* `. V
• 
  * a0 Y# l9 F& z% q$ d6 @: T
       b=0;  
  
  
• 
  
     if(r!=p1)  /*如果条件成立说明插入在r与p1之间*/  
  " e0 o! \( }9 }4 E8 e
  2 U" Y* F( t8 X7 c
• 
  
  8 {  @" U2 q  {+ x( J   {  
  
  
• 
  
        r->next=s;  
  & n' W! q, `8 J! |8 i5 }! v
  + T7 @, h5 M  i: n" a5 u
• 
  8 o8 v2 N" Y! F: @  [( n6 B* F
  " S, [2 i" p5 d+ w' h& K' }      s->next=p1;  
  
  
• 
  
  ; V# m% t4 e* J4 Y   }  
  
  
• 
  
  - l# f2 z( H; A# a   else  
  
  & i) h& M: w0 c$ J2 i
• 
  ( `: k4 `; |: R
     {  
  5 Y2 N6 E% ?$ o% ^5 f4 c- |
  
• 
  
        s->next=p1;  /*否则插入在就绪队列的头*/  
  0 R8 A6 F9 r6 D% S0 s; D  a0 d
  
• 
  / C# R, A9 d; q
        ready=s;  
  
  , \3 P! T( }1 k9 Y
• 
  
     }  
  0 N( N! C* S- p* l  W7 s
  & j1 A7 B& x- k5 j) g
• 
  
  }  
  
  
• 
  % J! P% q: Q8 I4 ^* D4 }, Y6 G
  /*优先数创建初始PCB信息*/  
  ' u' J! c4 u3 A3 k+ [
  ) q% h/ F: E/ \0 ^; @9 ]+ V
• 
  
  void create(char alg)  
  
  # M) _) }% o8 c$ s- @
• 
  - {/ f( J8 d3 A; I- g3 L" x8 W
  % f' q8 n. w! s{  
  ) v! {* t( ]" C7 q6 E# _
  ) h) S2 ^- q$ a, Z7 F: n! N. o
• 
  
  ) g& C" u2 |+ _; S- ^: H   PCB *p;  
  
  
• 
  
  * ?: M- I5 z! V: c/ O   int i,time;  
  
  
• 
  
  % J7 F2 j0 V1 s0 g   char na[10];  
  
  
• 
  
     ready=NULL; /*就绪队列头指针*/  
  4 d& \3 G7 k5 k0 }
  
• 
  8 \2 W% i% e2 A! i+ H
  / v  P5 J9 Z6 c' R; M/ P   finish=NULL;  /*完成队列头指针*/  
  
  
• 
  ; l7 ?7 o$ F: i- j
     run=NULL; /*运行队列指针*/  
  3 G1 Y$ v1 q' ]. e) w& p. v
  7 ~3 B5 L* T) R5 }8 V* p
• 
  
     printf("输入进程号和运行时间：\n"); /*输入进程标识和所需时间创建PCB*/  
  + y5 F! t) T9 L4 e3 z3 g: P
  $ D- p7 a6 ~) v
• 
  $ r! ?2 [+ {# s: h; O9 t$ K
  9 v# ~3 {0 [6 r   for(i=1;i<=N;i++)  
  
  6 k9 e9 d7 N- G) M" d; `
• 
  3 u! o/ O# Z* S+ u# `9 \# F
     {  
  # ^3 W6 s- v5 v% F3 m% a5 e
  7 e- D/ e+ y4 L! \! ]8 E+ O6 w
• 
  7 a6 Z3 C5 p/ P, e
  - g3 M3 O0 ^, U1 _1 T      p=(PCB *)malloc(sizeof(PCB));  
  - m! m9 ^8 f( M* S* Y
  
• 
  
  ' J) ?2 G. j# t# E      scanf("%s",na);  
  
  
• 
  
        scanf("%d",&time);  
  % n2 T/ s9 G" W  K
  ; h/ h$ H7 ?! v' H2 ~* O
• 
  
        strcpy(p->name,na);  
  
  
• 
  ) {9 O6 d5 [: P8 m
  : L+ `0 s9 M2 `( E' E  n      p->cputime=0;  
  ( D1 k* M1 p5 ^- L5 _  h
  
• 
  0 z2 x; Y. P+ d6 T4 T. X
        p->needtime=time;  
  
  
• 
  
        p->state='w';  
  
  9 n% R: k0 H( o$ \/ @3 o
• 
  ; v- v0 T& e& Q7 c2 Y& B
  ) |# u$ P$ N1 @/ l7 i      p->prio=50-time;  
  ( B9 `% Q" x- D! S) }; W7 Z
  
• 
  
        if(ready!=NULL) /*就绪队列不空调用插入函数插入*/  
  
  & e8 R. L3 G" g
• 
  ) ^# Q$ f1 D. }; E
       insert1(p);  
  ( T8 n$ [' j! U9 K1 l$ n: F
  8 T2 B! z/ {) R+ i4 n" B, s% Y7 H
• 
  
        else  
  ! l, [* k2 e# w+ P  B9 w4 T% }; y8 E
  8 @/ r4 s6 j: |: O. e/ E
• 
  8 ~  V5 B6 H; R& J: ]
  # Y2 U# t; ]% \; K      {  
  
  - m: E4 q1 q: d2 ~4 s6 H( i% H
• 
  + S; T% e% k$ a9 o" s7 H" e, H) g
  & ?1 W5 S, m$ u3 q     p->next=ready; /*创建就绪队列的第一个PCB*/  
  ; J) {+ L4 b0 R
  7 r! d& D  |5 ?" _( h
• 
  
       ready=p;  
  
  
• 
  
        }  
  
  
• 
  # Z7 N6 u" G; N
     }  
  
  
• 
  ( R, {- |& H! z' p# o+ d% D% O
  $ F0 ]" \' [% C" T+ i+ k; q! A) y  o/ `   printf("          优先数算法输出信息:\n");  
  & ]' e+ E; T+ F* q
  
• 
  ) Y0 B: p% k6 ^% g7 R
     printf("************************************************\n");  
  . k9 O- L) B! @4 p
  
• 
  
     prt(alg);  /*输出进程PCB信息*/  
  ; X9 c" J2 ^, u' U0 n0 d+ o
  
• 
  + I. Z/ @( r& p5 s+ R
  9 Y7 G9 S/ E. o   run=ready; /*将就绪队列的第一个进程投入运行*/  
  
  
• 
  
     ready=ready->next;  
  9 a/ W- _3 z6 l& ?! l" x8 S
  4 X% n" U8 U% F
• 
  # ?5 F% w4 c. L: p6 s
     run->state='R';  
  
  
• 
  # C9 ]1 B, L! N8 K
  }  
  4 s! Y; Y" p* T, j* M2 P; t: i
  & j  b! }5 P; a, ^( @& g
• 
  ' U9 C- P7 t6 J. y( [' L
  /*优先数调度算法*/  
  
  3 C; i# U' z$ H
• 
  : I5 b2 |0 s1 C: y. J
  priority(char alg)  
  
  ! w7 I7 i% B: [' X# \
• 
  
  ! F& b- X9 g8 g0 g6 ?6 L{  
  % K) z) R6 v0 R9 F
  + b  O0 }5 C; U7 A7 c3 C7 n; M
• 
  3 n4 ?" t( l8 i
     while(run!=NULL)  /*当运行队列不空时，有进程正在运行*/  
  
  
• 
  ' |1 e8 x7 o1 Y
  & d' U; d0 G% w$ ]( P+ ^& ~   {  
  ( g) p, Y3 t$ b
  
• 
  + _7 n( p; S4 i1 Q4 T0 B
  & i* t) _! G3 U  O$ K( V      run->cputime=run->cputime+1;  
  3 K% t! l* A; B9 D
  ' e5 N0 }# d0 ~2 l5 s2 U2 {; x
• 
  % O8 C. l. G0 z* Q, G
  ; f) S$ ^6 S8 z      run->needtime=run->needtime-1;  
  + g+ T' g, Q5 N2 l; p" r
  . H3 x( s$ e% }& C) s8 m
• 
  - ~) w7 s" P4 D- V  J  a1 B* g$ [: r
        run->prio=run->prio-3; /*每运行一次优先数降低3个单位*/  
  , T, d, ^$ J1 b2 }0 O7 h
  5 \0 B6 T8 a* l5 {2 ]
• 
  
        PCB *p;
  
  / Y4 K8 q" ?( o4 |
• 
  6 X* d4 }7 ]' ]( k: [
        p=ready;
  
  ( a% u6 \0 u6 s* j- f- ?6 ^
• 
  0 h; p+ ?$ o% C
        while(p!=NULL)  
  . L7 i/ a) q; J. d' l
  
• 
  ! D  g4 x' p' e( f! r( C6 X8 c
        {  
  
  
• 
  
  8 {) g& r; Z. e% w' ^9 c          p->prio=p->prio+1; /*每等待一次优先数升高1个单位*/   
  
  , X; j! v; ^/ R* t* `+ L1 I
• 
  7 E0 g, Y+ R  t& y, N' N5 S
  $ D8 G, J) ?" c$ ]' O7 m( J          p=p->next;  
  
  
• 
  - E7 r+ p" M( f* e" v/ b
        }  
  
  
• 
  
        if(run->needtime==0)  /*如所需时间为0将其插入完成队列*/  
  $ b7 C3 ^  @* \/ d* I
  : c% n- [% n$ f( y" n9 d9 X
• 
  
  ) @3 \3 m% u: M! @# W; x      {  
  
  
• 
  
           run->next=finish;  
  6 U: i0 z  `, D" I7 G+ l$ x2 ]
  
• 
  
  # T5 s7 T0 b9 v         finish=run;  
  $ B) p& A' R6 G) @7 @% W
  
• 
  $ A% C$ R, T- x; N. \2 t
    Q2 c6 G+ X! J) ~( T* `         run->state='F';  /*置状态为完成态*/  
  
  / L; `# t6 W( u+ y1 f6 A
• 
  
  + _4 I0 y% j/ r. w( b- L$ ]0 m& L! T         run=NULL;  /*运行队列头指针为空*/  
  
    @! G* q: O( h% d: v$ N
• 
  
           if(ready!=NULL) /*如就绪队列不空*/
  
  
• 
  
  5 I/ u! |0 g# D( `% e9 C         {  
  , E7 A! ~1 u8 e, ?: }
  " y6 H3 q: G( j% f
• 
  
              firstin(); /*将就绪对列的第一个进程投入运行*/  
  
  5 q. A9 t5 s2 c2 d8 c
• 
  - `5 I5 v; K& L* w& k9 }+ r# p
  / c' P4 v: l$ B/ d7 R1 w9 O: q         }
  
  
• 
  
  7 v1 Q, U: P( e5 [      }  
  
  * r5 g/ v$ }* D# R2 M
• 
  7 Z' h! W; g$ r" S
  # b8 G# m$ v7 A% u5 G: w9 Q      else /*没有运行完同时优先数不是最大，则将其变为就绪态插入到就绪队列*/  
  
  " S6 n' F3 n5 N. y6 q/ G
• 
  9 H; y$ V: Y: E6 F- e9 P$ J
    y1 }" ?+ U; e1 x+ j     if((ready!=NULL)&&(run->prio<ready->prio))  
  6 [- A: b  e3 T" F. [  u
  . b1 i5 t: M* V" @3 {
• 
  
  ) r6 B* u/ u# m     {  
  
  
• 
  
    N$ S; o8 Z( V1 \        run->state='W';  
  
  
• 
  . d+ Y+ C! {0 D" t2 m
          insert1(run);  
  % m3 O6 h; B/ c% X0 K) P
  
• 
  
          firstin(); /*将就绪队列的第一个进程投入运行*/  
  
  & V; z; |" \. p0 v7 W4 r; e
• 
  
       }  
    N: s, b; S# P) W
    m, N! P- J) q: w! B2 j
• 
  
  . m5 [2 d7 {: l& U! C2 I/ ?      prt(alg); /*输出进程PCB信息*/  
  
  2 A' ?4 x+ W' g
• 
  
  9 U, Z3 N, C. P2 Z   }  
  3 }+ Z% q9 H& O6 P
  + Y5 l- b/ w1 H' h
• 
  ! @; A+ q# V& |! P) o
  }  
  
  6 u. d$ t" J+ W0 }. T" G
• 
  
  /*主函数*/  
  * T  H' x1 M, H7 V, a, g8 s
  
• 
  
  6 [9 j6 i! a% w# c5 @$ \main()  
  
  
• 
  
  7 q) l+ |4 j. K' c' ?* ]{  
  
  $ u$ k6 q% w0 Z& o1 A
• 
  
  : G8 K. R: k) `! \( Y* H0 X! R   char algo;  /*算法标记*/  
  9 x: G. n$ N# u6 T: q
  ( _2 P7 q6 _  v/ a  r7 I' [4 K
• 
  ( g0 l+ H( t% A- d
  8 e2 |6 u0 C2 ]) f/ g9 T: e   printf("输入P确定算法：优先数算法\n");  
  7 F8 `# k& L8 R& a  U
  ' R' o/ M2 R. N! U2 \3 B" g
• 
  + d4 f5 ~$ Z% `+ A
  / ~. J1 Z4 _( E) }5 t- _6 U   scanf("%c",&algo); /*输入字符确定算法*/  
  
  
• 
  ) h) A$ i- E; |. \4 j% P
     printf("输入进程数：\n");  
  
  
• 
  ' V& w9 r8 y* D) H9 y/ D
  . o7 P5 X) b% ]+ T5 e   scanf("%d",&N); /*输入进程数*/  
  9 m3 ^# `7 d3 C
  8 I3 d. X" y* J+ Y8 I9 v
• 
  8 ^# x, k* r1 L/ [8 m2 Y
  : |5 [( j: h3 B: e* \" `   if(algo=='P'||algo=='p')  
  ( a& `4 I, R, t9 p& Z% i+ K0 x
  ' y: h5 X3 p/ a% l/ V& M# c% a
• 
  ' \) J8 v; X: V( q
     {  
  
  # a3 [( O3 k$ g7 u
• 
  
  $ {( A5 C: {4 i+ G      create(algo); /*优先数法*/  
  1 Q5 o/ G& t2 Y0 }0 U" l
  
• 
  
  $ q$ D1 i$ D* B      priority(algo);  
  6 b. I/ x% X# j) X1 N- {& F
  : l: V' Y! U) _
• 
  . p0 A3 w; W( l" I# e; N
  & o) B; R3 G7 s* j) h( k3 L4 x   }
  
  
• 
  
  }
  5 c% R( ^: k- q' E0 G7 _" U
  
  

输出结果：
4 c% d0 k' W  T4 l

; U/ Q, d$ e8 m& p3 P原文：https://blog.csdn.net/weixin_40962955/article/details/80072769