优先级调度算法

杨利霞

优先级调度算法

算法介绍
优先调度算法的类型（用于作业调度）
1）非抢占式优先权调度算法
系统一旦把处理机分配给优先权最高的进程后，便一直执行下去，至完成。
' `. |% i) r$ e- T: R2）抢占式优先权调度算法
& f, p2 J1 j- E: z4 e7 m只要系统中出现一个新的就绪进程，就进行优先权比较 。若出现优先权更高的进程，则立即停止当前执行，并将处理机分配给新到的优先权最高的进程。

优先权类型
) u! Y- G5 @3 @% z% N/ K1）静态优先权
静态优先权在创建进程时确定，且在进程的整个运行期间保持不变。
% x) K# N; C2 K/ P5 c( R

2）动态优先权

算法实现

抢占式动态优先权：

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

• 
  5 |. l# W* z% p  X# y" q
  #include <stdio.h>
  2 _' ~$ [# T0 O- _
  ! r; L3 i8 {* F# K# X
• 
  
  #include <stdlib.h>  
  * O1 b' m0 {# Q" }
  
• 
  1 n1 d. ^/ M4 }8 P$ h; o- h
  * G9 W- a5 Q- _% E/ A8 ]#include <string.h>  
  ! j1 I- a# D* R0 {1 C
  . |9 m, V  \: V+ x) O0 U1 Y
• 
  3 I  T( A1 b" X  r
  , k$ Q, z5 F- N5 ptypedef struct node  
  
  ; h) S7 ^! S3 O- O6 R; }" @: k
• 
  
  . `( @$ i. P; R4 K& }' K{  
  ' S+ ~5 Y$ d7 ]8 T; t/ f8 p
  
• 
  ( O6 ?9 P  X& x: B  ~
  4 q. F% E* y4 `2 I9 |2 D   char name[10];  /*进程标识符*/  
  
  
• 
  
  3 ]0 o1 ~; @. s) b   int prio;   /*进程优先数*/  
  * X, V* o" @/ s
  
• 
  
     int round;  /*进程时间轮转时间片*/  
  8 ~8 D5 j$ F4 y" a) T
  : d2 O9 l$ O+ `. L# Q
• 
  - V0 Y! p7 ^* _: W( Q1 g/ V
     int cputime; /*进程占用CPU时间*/  
  
  
• 
  
  , I3 O' a1 ?6 C2 H  f* W   int needtime; /*进程到完成还要的时间*/  
  
  + H8 m! q/ q% `# d" x
• 
    O* O- J( v8 x8 Q8 Y  d5 ~
     int count;  /*计数器*/  
  / I4 K8 T' ]( n7 {- }# y
  6 q7 \8 h* B* I' {* r' A
• 
  0 _7 k/ H8 R7 |1 f
     char state; /*进程的状态*/  
  5 \2 d8 o% s; k7 q
  
• 
  
     struct node *next; /*链指针*/  
  0 ~" M6 S$ f5 x4 Y6 Y/ a! V; l
  
• 
  
  $ N" u" j( U3 J7 H+ L: }, l3 c* ~}PCB;  
  
  % k# Z- A, m0 K
• 
  $ E$ r# [$ g; m4 ~( E+ R
  PCB *finish,*ready,*tail,*run; /*队列指针*/  
  
  
• 
  
  int N; /*进程数*/  
  
  
• 
  ' B9 V9 Y8 y+ v; @1 D
  6 ?6 o5 s' a4 ~0 }4 R1 v5 d/*将就绪队列中的第一个进程投入运行*/  
  
  
• 
  8 s# v' d; D+ K$ M, z
  firstin()  
  ( Q/ p6 P3 g8 Z2 E
  ) y  d5 K$ U$ ^; O
• 
  1 O% l! _- D5 w
  ( w* G! k4 ]9 B1 H{  
  + i! J- t7 R: m+ v8 Y
  0 [1 `. `" z* J5 y, i8 ?1 Y$ t
• 
  - c/ N( }7 P9 M: y% [
  3 L. n& ~! p3 \4 u* {& s. {# Y   run=ready;   /*就绪队列头指针赋值给运行头指针*/  
  
  
• 
  ; K7 Q6 r6 s  Z; `1 W
  " V, L& U' [- ?, E4 I1 |   run->state='R';   /*进程状态变为运行态*/  
  # c6 R1 K) H, x4 I5 z
  
• 
  
  : K4 K5 X& m* m" s; W) Y7 W3 L   ready=ready->next;  /*就绪对列头指针后移到下一进程*/  
  
  ! e, i. r+ k, g) w4 F1 H
• 
  
  }  
  ; x3 t$ O, d8 E8 L! A
  
• 
  6 U6 F6 y* G2 ~& x
  ; l/ k: g7 Q2 {0 ^/*标题输出函数*/  
  
  
• 
  ; }5 C! ]6 M# i% w
  void prt1(char a)  
  ' K' A5 M& V$ z5 D; `) H+ s0 O3 W0 w4 W
  1 _  c- O' V* G8 u" v
• 
  ; @+ O$ {9 [' @
  {  
  " U. V* L  c& c- a
  
• 
  & P' e+ B4 \  d& ^4 z* \1 [6 S; i
  0 e8 x# {, k% ^. S7 n" d" d   if(toupper(a)=='P') /*优先数法*/  
  
  : V6 @; N. E3 s- y
• 
  
  4 {: O  J* x* g) z6 J      printf("  进程号   cpu时间  所需时间  优先数    状态\n");  
  ( y  N/ K  _+ a% H" m. N4 |
  
• 
  7 y8 ]0 n% ~4 u+ D9 @- @5 _) S
  + T) O6 p: Z, g) P0 V   else  
  - k: y* M4 B  W  X$ i3 T3 i
  / q$ [4 p% c! a# Z1 G$ p8 t
• 
  $ e4 K/ r7 S! ^5 B* I" ]
        printf("  进程号   cpu时间  所需时间   记数   时间片       状态\n");  
  
  
• 
  2 F  ^# L% h. [
  ' v9 Z1 S! a! r" H& V  a' P! e3 o}  
  " P- j, B: C3 `0 a. ?. Z* \
  / I+ k- o: u* |2 L7 v, G7 i
• 
  
  /*进程PCB输出*/  
  
  2 L* i9 B4 P) K9 D" m" |
• 
  + A5 [4 v8 j9 ]$ u" _  I6 x, r" z
  void prt2(char a,PCB *q)  
  
  0 a, L$ W& s* J
• 
  
  {  
  
  
• 
  
     if(toupper(a)=='P')  /*优先数法的输出*/  
  
  3 O2 g; F0 ~) m
• 
  
  $ e7 R5 j: u: C0 R, y      printf("  %-10s%-10d%-10d%-10d %c\n",q->name,  
  
  % t. L! S0 d0 b2 g
• 
  ) N! H# u3 ^0 t; [1 X7 w2 k4 u
         q->cputime,q->needtime,q->prio,q->state);  
  
  # r! J5 I* Z. v2 s) \* T8 n
• 
  
     else/*轮转法的输出*/  
  
  3 t0 n2 ]0 P* C% |* P. ]! F
• 
  
        printf("  %-10s%-10d%-10d%-10d%-10d %-c\n",q->name,  
  
  
• 
  / V' N+ b- W) f" @. B
         q->cputime,q->needtime,q->count,q->round,q->state);  
  
  $ D- r9 ^1 u( o$ T, s& o
• 
  
  }  
  " P( `0 @+ ]4 h& ~+ {* q% _* v
  
• 
  
  /*输出函数*/  
  ! L  F  {1 {0 [1 ]. r
  
• 
  
  : S' q) d0 O$ x. Y; ~void prt(char algo)  
  
  
• 
  
  $ a9 E5 Y( M# t2 V+ E{  
  8 @) D  e" r/ D
  
• 
  
  % k7 S3 r# x: d' y9 ~   PCB *p;  
  
  2 ?( R# F8 b# Q, M
• 
  
     prt1(algo);  /*输出标题*/  
  
  
• 
  $ a3 D) l# o' }, V; F0 f1 D7 u
  ; m- ^% j' T- t* Y5 \: D$ Q# |# a   if(run!=NULL) /*如果运行指针不空*/  
  4 H5 P0 e+ n" F( a
  
• 
  
        prt2(algo,run); /*输出当前正在运行的PCB*/  
  
  3 [1 c7 q2 H. _1 T" s2 t9 T# q
• 
  3 p  V, G. m$ s9 ^5 ^- \( ^% l
     p=ready;  /*输出就绪队列PCB*/  
  ; x- w; U! v% }+ @& ~6 Y
  
• 
  
     while(p!=NULL)  
  ' w! D$ l( y" g
  2 g) J0 G/ t2 `, |9 s
• 
  
  & p  W* v# \* A3 y   {  
  
  
• 
  
  . T  C: H- O1 Z/ i. |) \      prt2(algo,p);  
  , a4 w4 d9 T0 z) {' ]/ X5 g* \
  
• 
  
        p=p->next;  
  
  : p; `5 z, J7 Q5 T" f/ a
• 
  
     }  
  
  
• 
  
  7 X6 g7 x; u1 ^1 m1 {: Y/ m   p=finish;  /*输出完成队列的PCB*/  
  
  
• 
  
     while(p!=NULL)  
  4 V) y% F. y4 Y2 C% r6 p/ b
  / g) j  `' k4 g
• 
  ' G6 w1 b: G" N4 t! b. Y# v
     {  
  / K& A: [4 j5 l: x
  
• 
  7 w# I% J' ]' I9 q& _  }
        prt2(algo,p);  
  0 p+ X8 Q, N; [
  ! [7 @5 O( T+ X4 j
• 
  
  5 e! i& ^! p' B7 Q, n/ G4 _3 D      p=p->next;  
  
  2 V% p8 q5 [" o+ d1 ~
• 
  
  2 D7 `/ l+ H: p  k   }  
  1 U+ V: @  D0 e" S! ]! ~
  
• 
  
     getchar();  /*压任意键继续*/  
  
  
• 
  
  . b' L# D: R( H+ C/ f6 k}  
  : D' }" f9 {7 }% ~% ^" z* @5 M! C7 C
  5 N  D# l2 z) Z5 j3 b
• 
  
  /*优先数的插入算法*/  
  
  * C& h. X' A- ^$ x
• 
  
  5 n! E$ n* u* E) e' A& oinsert1(PCB *q)  
  1 g5 j- ^' Y; @, v
  6 l3 r" N1 q6 R4 [, |
• 
  * l1 x/ y  s' W* M% b
  - [: w. d, y1 T{  
  
  / d  e; j  Z2 y$ `  c2 B
• 
    E- |4 K2 o4 R( B/ C0 Z
     PCB *p1,*s,*r;  
  - x1 x  _* E$ R, s# \9 `6 Z
  1 |" {" R5 a* D5 Q& `' N# y) n* y
• 
  : L1 {5 v5 t  a- h. a7 E# o
     int b;  
  $ t5 z9 R+ t1 g1 {
  6 x; Q6 r3 c6 S) _  s
• 
  5 F' J1 V6 I9 ?5 V
     s=q;  /*待插入的PCB指针*/  
  
  
• 
  
     p1=ready; /*就绪队列头指针*/  
  
  
• 
  
  4 X, o; k  ^' }   r=p1; /*r做p1的前驱指针*/  
  
  
• 
  8 F3 Q' b% _& q" q
  1 Z7 P% k* `6 l4 V, X   b=1;  
  9 b( C8 O5 b2 o& r
  2 |6 C0 t1 r. d) R1 F
• 
  
  ) i+ w9 i- B8 h. s& u, h   while((p1!=NULL)&&b)  /*根据优先数确定插入位置*/  
  
  
• 
  
        if(p1->prio>=s->prio)  
  $ U' V0 e! Z! k5 m/ r8 n; V( G
  * b3 O( R# g$ Y8 P- V. n2 d0 [- x
• 
  2 M$ s& I7 n& Q8 q8 h
        {  
  
  & a2 X- P7 w3 \8 [
• 
  
  1 G' M+ y6 G- q1 n     r=p1;  
  5 ^7 |- q! p. k2 Q2 `# ?
  
• 
  7 ~4 V1 p! N8 |) Q  N! i% G
       p1=p1->next;  
    O) U( v" {6 ?, K8 m' L( _0 c! c
  
• 
  
        }  
  , K3 X9 t; {' A' o6 J4 r. K9 C
  
• 
  
        else  
  . m/ f7 A; X  V5 `3 X/ Z, l
  
• 
  
  + f% O' y( @% b- [     b=0;  
  
  ; w* b9 y* x& j3 z
• 
  , }! j/ y0 ?, C1 @
     if(r!=p1)  /*如果条件成立说明插入在r与p1之间*/  
  4 Q, Q9 j' h; z& h
  
• 
  0 N4 ?; i5 ?  u
     {  
  
  
• 
  
        r->next=s;  
  
  3 F) v( k$ S) K0 ?0 U
• 
  
        s->next=p1;  
  5 Y. B5 w# a7 X* g1 n2 X# n
  ( I  ?' Y3 u( ]! ^* W
• 
  
     }  
  
  3 S/ G) z4 x( @# x; T6 `# B/ h
• 
  7 Z2 F' @7 g) B2 U5 k+ d" Q
  - b. z! r8 |4 K3 C   else  
  * i" B, q* k% p3 |% c0 q* ~% t
  6 z! H3 L) S1 k; W. h# Q; J! H( G
• 
  ) q. ?: o) T- X; A2 Z( o
     {  
    O* k2 @- I- R7 U) H
  
• 
  
  + O0 }  x$ E1 s      s->next=p1;  /*否则插入在就绪队列的头*/  
  
  
• 
  6 I# f$ L5 k% p
        ready=s;  
  
  . g' n4 X7 ~# X  S% m  T8 |* b
• 
  
     }  
  5 o2 I' T! q5 b1 F& ?
  
• 
  
  - |* V5 B7 i' m% F) D% w+ P# c}  
  & b6 i' S+ w8 G1 ~% ^
  $ r( a. J' F, m, A7 W
• 
  
  7 ^+ g4 Y7 ?3 l  N6 K/*优先数创建初始PCB信息*/  
  
  
• 
  
  ) I1 a3 Q5 M5 d! u/ ~9 U- L# Z$ T1 @void create(char alg)  
  
  ) }& l: Z. l0 _+ }
• 
  % x/ p, Q! G% t6 J( h" ]& G& J
  {  
  
  : M0 s& j: f9 i2 ^
• 
  
     PCB *p;  
  ! X0 ^4 G7 s3 W2 B! u* @9 L3 F
  ) ]: Q" N0 }! o2 v8 v6 J
• 
  
     int i,time;  
  
  , Z: o! R' Z( C% b$ }2 B
• 
  ! b( ^$ o) u2 ~! u
     char na[10];  
  
  
• 
  ) b: D# b3 v6 V& _) C3 c
  8 F! D$ J! E, M9 n) {$ G! ?7 q   ready=NULL; /*就绪队列头指针*/  
  
  ( v; y  J* `3 t7 b( g3 H
• 
  
  ; o- Y: M4 ?# T( K   finish=NULL;  /*完成队列头指针*/  
  9 ]2 C+ k, I! _' s( P* P% m4 S2 t8 d9 ^
  # v+ m& G3 w8 L0 s" _
• 
    H. b$ e9 [. X) C; e
  $ u  P" d% H8 B7 X   run=NULL; /*运行队列指针*/  
  
  
• 
  2 ^6 ]/ v5 Q: c( q0 i6 [
  7 N9 V+ l. b8 p- P3 Q' p   printf("输入进程号和运行时间：\n"); /*输入进程标识和所需时间创建PCB*/  
  
  
• 
  , j/ F$ I, V, o: k6 ?' W9 u4 G0 B
  7 S- C% g1 z  _- g   for(i=1;i<=N;i++)  
  3 l' X! \6 \6 g7 q( @
  
• 
  
     {  
  
  ( J8 ^8 u0 P. B0 i
• 
  , g* s0 ~& u# O- e! P7 O$ Y% F
  1 g% U& K0 B: K: M3 D: |, b      p=(PCB *)malloc(sizeof(PCB));  
  , o" y$ a9 G- p$ a5 @
  4 v; F, G8 q# D1 R! V
• 
  
        scanf("%s",na);  
  " a" d2 `1 {: J. f2 A$ ~1 R' U, }
  
• 
  
        scanf("%d",&time);  
  
  " s0 n: k0 L; \3 n" |: Q4 A
• 
  , Y: p+ `0 G4 n, I
        strcpy(p->name,na);  
  . v% R+ r6 W8 q  l! U
  8 f) p! Q9 X! g
• 
  / m+ G! o8 g9 ^9 `
        p->cputime=0;  
  
  0 y1 _; B" H# X7 T; p
• 
  2 m( `4 T2 C# h: L; k- I
        p->needtime=time;  
  % N/ Q$ ?: Y( y) l
  , n; z0 \* U  i" u' E" c
• 
  
        p->state='w';  
  
  
• 
  
    y- _0 g5 K" {, Q      p->prio=50-time;  
  - O6 {. w4 A0 P! C$ O! V+ ^
  
• 
  
        if(ready!=NULL) /*就绪队列不空调用插入函数插入*/  
  
    I* Z1 |0 a8 b2 G& l  H- r. b: P# w
• 
  
       insert1(p);  
  
  % Y. m- X- E( v( u
• 
  
  ) x. z( ~. M. [) s2 J: p8 ~+ b      else  
  
  
• 
  6 l- z" [9 `5 X% I
  ) e2 G" ]: o* s8 p1 m* g# v      {  
  0 _3 M3 e& A+ ]; U; e. y" ]" q/ f
  
• 
  0 `! b, |; D; Y; V4 P9 ~
  . w; O. t4 X# H- g     p->next=ready; /*创建就绪队列的第一个PCB*/  
  
  4 Q# x8 D& R, K6 Z0 x2 T
• 
  
  8 Y: c1 o+ M) w2 q3 a# u4 H     ready=p;  
  ' G6 D5 c9 L/ T/ |% n
  % V1 I5 M8 ]; |7 ]" j, J
• 
  / w- ]- O! x1 B6 g( O! J
  ; Q+ R9 n0 f/ b- e3 `      }  
  
  ) w" t) M) y" m0 F6 x( e" `
• 
    ]3 R4 i! m( Z8 R5 }3 a
  4 Q4 D. ?% k1 n   }  
  
  
• 
    n; c! d& B5 n1 @( I5 E: b
  # V+ s, `& _& |1 T' G   printf("          优先数算法输出信息:\n");  
  
  
• 
  " _* h! O: o  |, x
     printf("************************************************\n");  
  
  
• 
  
     prt(alg);  /*输出进程PCB信息*/  
  
  ( Q' h! @5 ?9 ^" M2 f& T# ]
• 
  
     run=ready; /*将就绪队列的第一个进程投入运行*/  
  * _$ H- S' X) b0 ~
  4 t" b# O0 R( X  X: f
• 
  6 V# X4 e' [5 r" |: ^. h
     ready=ready->next;  
  
  
• 
  
     run->state='R';  
  . L: ?( a- g7 L( n
  2 J3 E2 K' A8 K8 D2 ?" S* `
• 
  : h+ e7 Y- ^) A: t8 e) y
  ' Z! P* q: t' b; [8 s# z0 O}  
  
  
• 
  
  : ^; r4 M+ p6 @7 X/*优先数调度算法*/  
  % j& M  g- N: J( K- E' b
  
• 
  
  priority(char alg)  
  
  2 D; H! s1 {6 A4 Z6 e0 ?! i
• 
  
  1 E( N! s* N7 r! z" f: m% K{  
  3 o5 Z+ B1 V, v1 k5 c
  $ Z; O9 p2 p" @. o
• 
  % ~7 K8 [7 A- v) `6 j2 l, _
  . j* F% P( n1 q- Q5 b0 k   while(run!=NULL)  /*当运行队列不空时，有进程正在运行*/  
  % g  S& I" [9 H, [
  7 Y9 X4 |* w+ b3 [
• 
  
     {  
  
  2 j& I  m$ ?5 L# |/ g6 x: Z
• 
  
        run->cputime=run->cputime+1;  
  
  2 L0 I9 w, F; `( m5 Q3 t3 X: \6 t
• 
  
        run->needtime=run->needtime-1;  
  " E3 K5 c' X. s) }+ M2 k
  3 A& y* K2 w0 _1 u/ e
• 
  
  4 i# W( K+ L$ n) ^& `5 L6 c      run->prio=run->prio-3; /*每运行一次优先数降低3个单位*/  
  
  
• 
  
        PCB *p;
  $ D% ?4 H/ _# q0 {7 J
  . {5 k" ]1 f* t) f, Z
• 
  
        p=ready;
  
  
• 
  
        while(p!=NULL)  
  - c8 w5 W' U7 s$ E
  . B+ N- V1 s6 a, Y: Z  C% ?, u  @
• 
  
        {  
  
  
• 
  7 Q8 R7 z- {9 }  s; v
            p->prio=p->prio+1; /*每等待一次优先数升高1个单位*/   
  ( \5 f# d/ D* W% a3 o* V; _" D; \4 x
  * w' Z  D2 U$ m  E7 g; u; Z
• 
  0 U* e0 _" A. f/ Z" H+ y, W
            p=p->next;  
  
  - ?& I! f. h2 [4 }
• 
  
  & ~3 I* }$ z" p/ N- [; y/ {+ j6 n      }  
  ' x2 Q2 l/ N- c/ A5 [
  $ J" z4 P7 h* {# v$ _  ]5 ~
• 
  
  ; ^& L% D: ?6 {- t  H! i+ I4 w      if(run->needtime==0)  /*如所需时间为0将其插入完成队列*/  
  - M( R: Y6 z" J7 \' |& C1 g" _
  % `  ^1 B: Z3 X0 z  t+ L
• 
  
        {  
  
  
• 
  
           run->next=finish;  
  , _- \5 k, W" }2 `, Z/ C1 Y
  
• 
  - O/ l& J, g* H
  0 }( _: t/ \9 I# O7 e         finish=run;  
  
  # d4 Z4 h% d$ Y- @( x) a7 m0 V  T
• 
  8 w6 A: \( P: N5 x, j. J2 L0 o0 o
           run->state='F';  /*置状态为完成态*/  
  # M0 U. w& W6 G
  
• 
  8 `1 e; A$ T+ M7 I9 F$ H3 J
           run=NULL;  /*运行队列头指针为空*/  
  * J, `+ Z7 w6 @$ ~3 z
  ) z) d( ?- R% r- G# D
• 
  
  $ \7 s$ T. }  p$ q0 j/ r% c         if(ready!=NULL) /*如就绪队列不空*/
  
  
• 
  
  / a; n: f. v% ]/ v1 {& l* q7 l) I1 i         {  
  
  ; p8 L+ B4 |  V$ U& q
• 
  
  ! P# G8 i* i% r/ R            firstin(); /*将就绪对列的第一个进程投入运行*/  
  
  ( t) R: f1 c7 _7 \+ d0 M
• 
  
  - k. K! {8 E/ t  z' i% ~& D7 b         }
  6 \* g) c. @! F. k. v" b
  
• 
  
        }  
  + A# ^! z9 R. |. t  u: K
  $ ^4 }' D) V3 B9 x& N8 M" H
• 
  
  # L; `' I# D+ p/ B7 I# O$ N      else /*没有运行完同时优先数不是最大，则将其变为就绪态插入到就绪队列*/  
  
  
• 
  
  4 R. `2 S) t% P     if((ready!=NULL)&&(run->prio<ready->prio))  
  ; q7 n6 u& I+ ^; }
  4 v# i* ~) b* O" r
• 
  % d8 D$ W3 e* O
  3 p3 j) g1 C  V; J3 W     {  
  # Z6 w( ?2 R1 A  C1 o% s
  
• 
  
          run->state='W';  
  
  % L% e  ~1 Z: `3 \0 f. i
• 
  " r! [9 q3 S& K: W( j5 t( w; V& E& |
    N- k/ @2 V( ^8 m1 z, `. C        insert1(run);  
  9 X9 s! |& @4 @
    [, `( \9 x8 m" n/ E+ ~3 p
• 
    T) j, ]& z. o
  , L/ d, {, Q# X% b4 s        firstin(); /*将就绪队列的第一个进程投入运行*/  
  8 _1 m( ^  D! E2 a( J
  
• 
  & g- R/ ~4 k$ J! @+ t
  9 p0 H9 t. \0 p, O* E: L     }  
  8 Y9 J# C) [1 ?% k' u+ b( p
  
• 
  ! o" T+ D. G  _$ K8 E4 \
  5 C# R8 b: D. A- y      prt(alg); /*输出进程PCB信息*/  
  * V) f" T" C, B& G% a, y1 X2 X9 w6 l
  
• 
  " s4 t7 B- b+ c0 i0 g
  0 R/ S4 A2 B8 m# g/ q5 _; Z' A   }  
  
  ( t- M! {! j* Q! t/ J) w
• 
  
  }  
  
  
• 
  
  & j- U+ ^  c( D3 o( |/*主函数*/  
  0 {- Y) K( _6 {
  
• 
  
  7 E1 V/ m. {' O0 B& Omain()  
  
  " @' F; ], S0 [: u6 B) U1 }! @
• 
  
  {  
  0 G- v  J6 Q, W* Q; k
  
• 
  5 a( l; G  z4 m6 r1 Y, N" K
     char algo;  /*算法标记*/  
  5 H! `% r, q! u, b
  
• 
  
     printf("输入P确定算法：优先数算法\n");  
  
  / ~+ X/ k& S: v7 ?
• 
  
  ) V2 N0 f' j' O4 y   scanf("%c",&algo); /*输入字符确定算法*/  
  ( m: |  B+ p( f
  
• 
  
     printf("输入进程数：\n");  
  
  4 p* e% B0 b  G" E. K* f' g  {; z
• 
  ) H! e5 d( s! X- t/ v$ ~5 B4 r
     scanf("%d",&N); /*输入进程数*/  
  
  8 L% x2 \: I; j
• 
  & o/ A7 U; a6 h% _! ]& \
     if(algo=='P'||algo=='p')  
  ; e3 ]- N/ I& X; X% G
  
• 
  
     {  
  
  4 l7 t) _" f# {# [4 e
• 
  . H3 [) l" l" C& i2 }
  : \3 [3 }; J) s% W7 c! [) F, O      create(algo); /*优先数法*/  
  7 J. |2 ?' }' m( p  B. h
  & B: R6 V2 X' [( j  W# s
• 
  6 F7 q6 w' H5 k2 t
        priority(algo);  
  $ h. `/ [' @9 s' z) e
  
• 
  ( J: I: p  `: r3 o( P
     }
  
  , G0 s1 ]: f, F
• 
  
  }
  
  
  : {: G5 e, w6 _+ e

输出结果：
& ]; |; d/ [/ s' S. @* n

6 r8 ~9 E, `9 ~) h- G* p! t7 p4 D原文：https://blog.csdn.net/weixin_40962955/article/details/80072769

- K, w1 p% Y* {" O  N& H