优先级调度算法

杨利霞

优先级调度算法
. [. ~1 |( v! K1 u& ^

算法介绍
优先调度算法的类型（用于作业调度）
- V! V" \5 P1 g% y% r( y* d1）非抢占式优先权调度算法
系统一旦把处理机分配给优先权最高的进程后，便一直执行下去，至完成。
. Y; M( y/ }" |/ ]$ q( p9 @) m0 Y2）抢占式优先权调度算法
只要系统中出现一个新的就绪进程，就进行优先权比较 。若出现优先权更高的进程，则立即停止当前执行，并将处理机分配给新到的优先权最高的进程。

优先权类型
1）静态优先权
$ ~' ~' N" i, o7 M静态优先权在创建进程时确定，且在进程的整个运行期间保持不变。

2）动态优先权
8 I; x5 M! d$ F! n

算法实现

抢占式动态优先权：

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

• 
  
  #include <stdio.h>
  
  * L7 ^5 Y5 S. ?! ~+ Z. o
• 
  
    {+ f# j- v, [* O8 y8 S/ B#include <stdlib.h>  
  
  8 ^1 r5 z$ D1 G9 y7 e! o
• 
  
  #include <string.h>  
  
  
• 
  ( L0 O2 i6 _+ c
  typedef struct node  
  
  
• 
  
  {  
  
  ( @. W, R9 l, p
• 
  
     char name[10];  /*进程标识符*/  
  
  7 G9 V9 ?" h9 X" H
• 
  " s" s' x: Z- ]+ G! C2 j; }, e6 p
  5 r& g* `% K# c4 @/ }, \, L+ F: o   int prio;   /*进程优先数*/  
  
  " [' }- J/ A$ Z+ R0 j3 ]# [( u0 D8 k
• 
  ( ^! O; y6 ~' R- F; U
  4 T7 Z- z; K9 X, M   int round;  /*进程时间轮转时间片*/  
  ! s) A4 R" v8 u4 I7 p
  
• 
  % g# {3 p) Y. g$ B2 y) _! ~; J5 U: u
  % O% C5 T2 Y2 T/ U   int cputime; /*进程占用CPU时间*/  
  6 D/ I, _0 {1 ^% n" t
  1 ~" J! i; |+ P
• 
  
     int needtime; /*进程到完成还要的时间*/  
  5 W; d3 d3 q' m- P  e2 S# w* t
  * A* |6 j& A) ]  }/ H. ^; Y
• 
  ) G; u, V" ^5 ]7 h$ P0 q  [
  * z  J' I7 j" Z( i   int count;  /*计数器*/  
    j& H. y3 O4 [) L6 o
  4 {4 V( E: t+ W$ s' t: e: u
• 
  
  : f( N; |! }; N# p   char state; /*进程的状态*/  
  ( E4 `, Y+ [) o3 x: O, d
  
• 
  
     struct node *next; /*链指针*/  
  
  
• 
  $ ~9 u! L% `% X; U. P- S
  }PCB;  
  
  
• 
  3 Q& d# W$ u0 q9 j  F* R
  - ]! A& V, Q' f8 XPCB *finish,*ready,*tail,*run; /*队列指针*/  
  
  
• 
  
  ! x6 O0 N4 X! H4 @int N; /*进程数*/  
  6 r# s* u, \7 Z- e6 ~( Y: \4 M
  ' [% d/ q4 `) I5 I4 _( O
• 
  $ H+ p* m% N) T- _+ E+ ?: a
  /*将就绪队列中的第一个进程投入运行*/  
  : _/ p5 V- X: N
  
• 
  . ~0 s) m* M: ]7 l4 v0 g& a
  % H( a2 N, V* Y# q. M. p/ Afirstin()  
  
  
• 
  
  + H5 Z5 c; D& a7 K: k! X{  
  
  ( W; N2 \5 J" N. U3 r
• 
  & o* U: Q" @5 }% x+ p- m/ G
  / D2 S6 x3 Z5 W3 g   run=ready;   /*就绪队列头指针赋值给运行头指针*/  
  
  
• 
  
  : b) ~$ a7 s8 i$ f; D: F! G   run->state='R';   /*进程状态变为运行态*/  
  % w: c1 @- _0 l
  2 S# W! N" Z: h7 e$ T6 S
• 
  
     ready=ready->next;  /*就绪对列头指针后移到下一进程*/  
  ( `% A+ Z* ^3 e/ k3 s% ?% Q, H1 c
  3 ~. B& d, p: S7 e, u
• 
  
  & z2 o7 g7 E' [' t' P* w3 S. b$ q}  
  ( z6 l# U. d& ~( x* `! `+ o4 u4 E
  / v3 a% w( |, @- ?8 ~
• 
  
  8 d; u5 y, |4 k/*标题输出函数*/  
  
  
• 
  + n7 G+ ?$ c5 g
  " y2 l; o( f4 D$ G' d2 n" Jvoid prt1(char a)  
  
  
• 
  
  # k# b' s7 C8 I- _1 z' X/ P/ Z{  
  
  $ E: \! B7 d( j
• 
  
  ! l9 C! x2 [7 J   if(toupper(a)=='P') /*优先数法*/  
  
  
• 
  ! K8 w9 L/ g7 Z
  ) T: M+ Q3 B' v1 i3 D& V) V* Y      printf("  进程号   cpu时间  所需时间  优先数    状态\n");  
  
  
• 
  
     else  
  
  
• 
  + B. A$ D' p3 r2 d
        printf("  进程号   cpu时间  所需时间   记数   时间片       状态\n");  
  
  
• 
  
  8 a+ F7 w# u& Y}  
  
  
• 
  
  & w1 i. o. x* w2 p3 K* T/*进程PCB输出*/  
  
  ) L; b  _% ~0 A" O
• 
  
  " @8 |. Z" m" c' j: H/ c, j/ E4 _void prt2(char a,PCB *q)  
  
  5 G& A. e% n* m' B0 w0 \
• 
  * y3 L1 r0 H7 _: |
  7 I# I2 @' E/ u  i# R& u3 [{  
  ; ^% T; t4 `4 U7 N0 i% Y& x
  4 Y# G( i5 y; E+ l( {  r$ `( W. ]
• 
  
  8 ?/ O/ ~4 j# y, ~6 j. }& L/ F2 c   if(toupper(a)=='P')  /*优先数法的输出*/  
  5 J& H# U. A! D3 B
  
• 
  8 \+ q7 ]( B6 [& c, F
        printf("  %-10s%-10d%-10d%-10d %c\n",q->name,  
  
  
• 
  
  ; i$ M8 N( Z; P; j% t, g/ R       q->cputime,q->needtime,q->prio,q->state);  
  " f6 _6 I! ^$ f% ^, H5 H
  
• 
  
  ; A" l0 H$ c5 o/ i6 Q  `   else/*轮转法的输出*/  
  
  & X4 |" C$ t- Y* j& l  {
• 
  ; \- K& I7 t% B+ s5 c
    h2 S1 U4 Y0 B9 ]% h8 c      printf("  %-10s%-10d%-10d%-10d%-10d %-c\n",q->name,  
  
  
• 
  ) a+ b1 Q$ _3 ^( X
         q->cputime,q->needtime,q->count,q->round,q->state);  
  
  4 A2 ]. [0 e* p# ]% g) a
• 
  6 T: D& E) ?) T* Y9 S: @
  }  
  5 R6 [* m! @* P( Q! Q
  . Y& d& @- ?5 }( r: L$ r1 m
• 
  7 ?; g% S# |# s
  /*输出函数*/  
  " W2 ~8 @. C- C
  ' S  U- g- I: B  q. v
• 
  1 H6 h$ r+ o" S6 S" l
  void prt(char algo)  
  
  
• 
  
  6 {6 R. R6 j2 R4 `( G+ a6 X4 V$ D" g5 O9 i& l{  
  
  - i- n+ H/ ^8 q9 c' ]0 u; l3 l
• 
  
  ) b7 v1 }0 k4 G   PCB *p;  
  
  
• 
  / q+ I) u! \" L. ?2 O
    S5 h9 I/ N1 N- ]" V   prt1(algo);  /*输出标题*/  
  % |0 P: x/ c) T' _6 l
  
• 
  
     if(run!=NULL) /*如果运行指针不空*/  
  
  
• 
  
        prt2(algo,run); /*输出当前正在运行的PCB*/  
  0 R. w1 o9 m" v4 Q
  
• 
  
  % C5 N+ Y5 \7 B& E# L, I   p=ready;  /*输出就绪队列PCB*/  
  " b# S- k: ^% s
  % u1 y1 C, Z% j
• 
  - a3 I8 Q, A! U1 X$ p. m8 f- D# d
  8 c7 D- V! [0 q% c( s$ u7 i* e6 X+ u. d! C   while(p!=NULL)  
  
  1 Q- a" V5 I" }* X, x3 j1 D
• 
  6 P5 o! y7 K6 b
     {  
  : s+ E3 X% ]9 P# `5 B$ t
  
• 
  
        prt2(algo,p);  
  ! x2 |$ u- ~! L) F7 e) t
  
• 
  & g" n, m1 x$ [
  ) }& _1 q- ^! T$ |0 V2 _9 P      p=p->next;  
  4 J0 _9 m( e" {8 h. e6 p
  / y5 w0 H; E: ^# \
• 
  ( L; }0 ^. V, r9 Q2 B* X
     }  
  
  
• 
  
  9 N7 J" |/ C# G' ?$ i  I   p=finish;  /*输出完成队列的PCB*/  
  
  
• 
  ) R& Y  l# v" g8 @6 h" B
  : l, x, |' c# S   while(p!=NULL)  
  
  
• 
  ; e3 g1 I! a( o/ L. B
  ' s9 z1 `: i& a3 x* b   {  
  
  
• 
  
  " B; l) ]& }) H6 `, N      prt2(algo,p);  
  # ~& _' i2 j3 R: p) \1 v/ }- c
  
• 
  
        p=p->next;  
  & l) \- ~; O' @) J0 B7 R3 a: i
  
• 
  ' d5 f$ p' r4 C% I4 `7 g6 x
     }  
  , `% a- A" R9 W6 |
  
• 
  3 t% m5 \: b0 Q3 l% s5 C+ D
  ( E9 I- Y- }, t; i4 I; s   getchar();  /*压任意键继续*/  
  ( {* R+ t$ I+ c) o- A
  
• 
  
  }  
  : ^+ V2 z' B! l
  , F$ C" o# a7 J' Y( G
• 
  
  /*优先数的插入算法*/  
  
  
• 
  # _- _- v( @  B9 h: p1 `. b
  insert1(PCB *q)  
  - ^# D1 ^" C7 K6 p" D
  
• 
  
  {  
  
    `1 q$ @# W9 X  a
• 
  5 u: g: \$ s9 o
     PCB *p1,*s,*r;  
  6 E& W2 u' E; M% ~* U/ O- j" D
  
• 
  $ S. |7 l7 ~0 O' B; C  H
  * M  [. h! P1 W6 b* Q, I. Y5 R   int b;  
  4 b! d/ \2 i; y' K( K2 ~
  2 @; S8 e4 ?: X) j9 ~8 c- z
• 
  
  0 {* c$ K6 X8 |0 v' O4 W   s=q;  /*待插入的PCB指针*/  
  
  
• 
  
     p1=ready; /*就绪队列头指针*/  
  / ?5 j8 g" N" p! r( D, q" ?6 p
    u. s/ [- A: w$ ^1 C! S8 c
• 
  
     r=p1; /*r做p1的前驱指针*/  
  ' H& x' L$ D) E  {; z
  " @& y& L. s8 M, }/ \5 J
• 
  3 k. \, R0 E$ _: y0 g+ Y. V
     b=1;  
  
  
• 
  ' ]4 \4 R4 Q/ i
     while((p1!=NULL)&&b)  /*根据优先数确定插入位置*/  
  . Q4 \) G5 ~% I2 C0 F: k, v
  
• 
  + p9 j; e8 w6 U' y3 D% P
        if(p1->prio>=s->prio)  
  ' }' c/ f7 n% ^/ {8 P; W# N1 N0 S6 e: y
  4 z, l( a% {, K* a6 J( m
• 
  . @% J5 T7 E! S0 ~/ b
        {  
  
  $ l/ ^& c, K& F( B1 D
• 
  ( [) g# l/ {4 R( d
       r=p1;  
  4 T- A/ K# G$ _" u$ ?
  
• 
  ! J' f+ x$ V" C; @, U" a
  * K  M' b# R% j2 X- q     p1=p1->next;  
  . u! v  ^# K* \, K( C
  / D0 ~1 t, G! k  q' k0 ~
• 
  
  - z; h8 r2 ?" G% N9 G: Z) _0 k      }  
  ' v2 E( d8 n! j' A; j# f: D
  
• 
  
  ) e; O, p* q, N4 |0 w+ m      else  
  + |( X( x: [% |
  % Y7 q# w9 d0 E, Z& z5 _
• 
  
       b=0;  
  
  
• 
  ( p! r" C; q( V1 I* @0 f+ t% Y
     if(r!=p1)  /*如果条件成立说明插入在r与p1之间*/  
  
  0 `6 ^2 \0 J) |
• 
  
  * Q& N0 Q# B/ S) T! y, e   {  
  2 g! s9 M" K. u
  2 }- U. d" r4 a
• 
  ( {# a4 m2 v; Q1 S# W
        r->next=s;  
  
  
• 
  - b0 [9 r) `$ J# ~
        s->next=p1;  
  ; B' m, o* L. l9 I: b( D7 O
  
• 
  
     }  
  
  % Q  S' l4 s- {8 x0 o
• 
  
  3 t+ ~6 o; A8 {& K   else  
  
  
• 
  
  5 Z8 Q. K3 C- O" a1 R" ~   {  
  5 M! m" _0 P: v- q4 D5 H
  
• 
  6 I; m$ q, A, e# ], z4 \
        s->next=p1;  /*否则插入在就绪队列的头*/  
  
  
• 
  
  ! m4 J$ \5 G+ M. J: s$ o! N# A  m" C      ready=s;  
  ; W8 T: X1 G7 r% B; C9 h& ]0 a
  
• 
  0 q& z2 U6 v, }! t, s3 w/ r7 \
  + m0 \) A9 F2 Z3 ~! R5 @   }  
  $ `: \/ y" N+ B* ^* k
  
• 
  
  }  
  
  
• 
  
  /*优先数创建初始PCB信息*/  
  8 N* {# }& F+ Q
  
• 
  
  void create(char alg)  
  , U  [0 ]1 L* @" }1 c4 O& Y% n
  
• 
  
  - k6 N5 G$ D4 X{  
  
  1 y& O. m0 {6 v8 z0 [2 |) w
• 
  / p9 u' q! t0 l6 K: X
  % {% r) p. F1 t- |% @! ]/ N   PCB *p;  
  ( l" V( _( x6 N# k
  
• 
  - T) q, o- ]3 j& I- u
     int i,time;  
  
  ; H* Z/ C7 P) g3 v5 o  W, v; r5 v$ f
• 
  
  " V- ?* r/ ]" r% o# k6 @   char na[10];  
  
  5 ?  S' \& f3 {! u: v& @8 e% J
• 
  
    Y+ d5 e! Z9 @/ I( U: s- }   ready=NULL; /*就绪队列头指针*/  
  
  6 E" s; i1 o9 ~
• 
  : v9 v/ V1 Z# h7 `% Z# S
     finish=NULL;  /*完成队列头指针*/  
  
  1 S$ Y/ E$ \5 F5 U  E
• 
  . z/ _( ^+ c' z# i9 y
     run=NULL; /*运行队列指针*/  
  ; l5 D* e9 A( n' R/ T: h! R7 q
  
• 
  
     printf("输入进程号和运行时间：\n"); /*输入进程标识和所需时间创建PCB*/  
  - L* u+ p6 E. h
  
• 
  
  . ^+ W$ K) n/ x8 j' E   for(i=1;i<=N;i++)  
  5 ?. t) }' f9 ]& Z" N" w+ j
  : g1 p( m$ r2 a! |
• 
  
  " F+ Y2 i  Z* u4 \   {  
  
  
• 
  
  ( q2 ^3 v. Z% u2 @( W8 z2 f      p=(PCB *)malloc(sizeof(PCB));  
  : |! G; f" s( k, z% X3 j& s
  2 B6 d6 f* V3 k# U- }  A" ?" c
• 
  8 A3 o* c% L; M, Y  r; b1 X
  2 N  U5 @& |+ s. X" T9 X0 j9 q      scanf("%s",na);  
  
  
• 
  7 c( ~! [/ {7 B* G$ C( J; `4 F" K
  ; }3 {3 z" e4 Z; k" v" X. c      scanf("%d",&time);  
  
  4 G# S0 l& [4 K- B- @
• 
  
        strcpy(p->name,na);  
  + F+ z8 ]# y. t: E5 Z
  
• 
  1 O$ t2 y$ L7 ^2 ?, G+ [! f
        p->cputime=0;  
  
  
• 
  7 g0 _4 \& V; C. W) `
        p->needtime=time;  
  
  
• 
  , v, p9 q4 ~: t
  4 ]$ D# G5 b0 R      p->state='w';  
  
  ' s% E" L5 K) k- z
• 
  
        p->prio=50-time;  
  0 x/ \2 q, [5 ]2 q6 @# k6 {
  
• 
  
  2 E; E4 q( K3 P3 b6 ?+ k3 O/ P      if(ready!=NULL) /*就绪队列不空调用插入函数插入*/  
  
  ( V8 F$ Q1 ]$ q* F+ O
• 
  5 q* A; M  O( s4 h$ a% J7 F5 _7 R
       insert1(p);  
  
  
• 
  
        else  
  
  
• 
  
    U! i5 t0 _0 `3 n0 q      {  
  3 E" r( B1 \- T& b; E0 P
  
• 
  # X( c% ]& R5 @+ V) }# ~9 z& t
       p->next=ready; /*创建就绪队列的第一个PCB*/  
  : W' b7 s/ n! C( b$ m; G. [3 Y
  
• 
  
  % N% X% {" q6 U. D3 i     ready=p;  
  & C5 {! l! m1 O% R
  " d6 u1 x# I8 G/ z* u: ^
• 
  
        }  
  
  4 [4 K5 K$ Z  I7 m
• 
  
    V! T1 L  p" \. |7 P5 g8 i   }  
  
  ! Z" ?( y+ l' Z1 i- C( d
• 
  
  2 Z7 [: ~2 D5 p1 X  ~" Z   printf("          优先数算法输出信息:\n");  
    U0 X: O0 u& h1 ~& d
  
• 
  9 o! m$ J- ~& h: Y
  . N: X6 M6 [! g0 g0 t   printf("************************************************\n");  
  
  
• 
  0 R+ [: x+ V0 b% i. ~
     prt(alg);  /*输出进程PCB信息*/  
  ( v6 P- C9 _* K( B4 o
  
• 
  / L) y( y+ j) C& B3 ]2 D0 _
     run=ready; /*将就绪队列的第一个进程投入运行*/  
  
  7 P% t2 j0 Z) ]4 }& C. w0 Q
• 
  ; \, j( @* C3 `9 h6 ?$ f
     ready=ready->next;  
  
  " m' b: u: F- m! m4 {' X) {9 T
• 
  
  2 L+ j3 G& \9 r6 m   run->state='R';  
  - Y' Q: F: \5 m6 V8 w& c
  2 `4 v" z; W4 P: J6 t* v1 P& d. T
• 
  
  }  
  
  
• 
  * E6 t, G4 G7 ?! M8 e) v7 p5 A* R
    W; Q, q7 W  y, T) J; \/*优先数调度算法*/  
  # ^5 P) X- B  f$ y) Q
  % q; O" w3 g2 W2 U$ ]
• 
  
  priority(char alg)  
  6 P3 f; P8 o" h+ [5 A; Y. Y, Y
  2 d. B: N0 p0 y# m
• 
  
  {  
  
  
• 
  # X5 _, G" j3 M" ?+ v! p
  5 [- K' s. D6 A( X* s9 l   while(run!=NULL)  /*当运行队列不空时，有进程正在运行*/  
  : f1 C/ L8 s; P
  ! t8 q/ D/ \, L) i
• 
  
     {  
  * u, c' j& E# {6 ?
  
• 
  
  ( j4 _! M- y) j# \+ b      run->cputime=run->cputime+1;  
  9 \* o/ K+ Q9 O3 V- U4 \7 m
  7 @. k( I+ U9 @2 r# }
• 
  
        run->needtime=run->needtime-1;  
  
  
• 
  7 ~7 X- z! J. r. P; H# e- f/ p2 I
  / i( O1 \. E6 H) f8 b7 Q      run->prio=run->prio-3; /*每运行一次优先数降低3个单位*/  
  
  # a, P6 L; |5 P$ e9 X; V
• 
  
  8 A$ ?$ k9 _. L1 ^      PCB *p;
  
  
• 
  2 W& n, K7 d$ q5 b7 d. F# R! n1 ^
  : s7 S5 }! Z, ]      p=ready;
  
  
• 
  
        while(p!=NULL)  
  
  
• 
  
  $ Z- L5 n" e) y9 n* b$ y      {  
  
  ' [( D& f  C, L! A7 \5 b
• 
  9 n+ o& z" m! g" N
            p->prio=p->prio+1; /*每等待一次优先数升高1个单位*/   
  % m. u/ H, N8 Z+ F7 s
  
• 
  
            p=p->next;  
  
  
• 
    t  a3 I( ^/ S
        }  
  
  
• 
  ) u% ~" c9 f8 R6 n8 ]' k6 |
        if(run->needtime==0)  /*如所需时间为0将其插入完成队列*/  
  
  , }0 Q& c& ^* x7 A  X
• 
  8 P9 `: r: K1 R/ H# b3 O
  8 D" h. B' g) T$ V; |      {  
  3 I6 [. n( @( g& ^3 g- l
  
• 
  4 ], m4 {9 d" M" n. G
           run->next=finish;  
  
  
• 
  ' H, D' h2 c) ]- Z) x6 [4 ?: X, s4 j
  $ t0 |0 L6 W, q+ Y3 }% s         finish=run;  
  2 }% o: M) }7 B8 T% ~0 h
  ! q6 ]% k$ k$ G2 o
• 
  7 W! o9 a2 @) `$ T/ z
  + E; C5 ?% w5 S) Q/ b! m& u- i) v2 d         run->state='F';  /*置状态为完成态*/  
  
  
• 
  3 \9 v4 C4 V% T" @* e# ]
           run=NULL;  /*运行队列头指针为空*/  
  
  / N& c5 h2 E5 ]' x
• 
  ' x4 L) h# Y& n, u6 b+ _; M
  9 Y2 k9 C  J+ a/ e! N         if(ready!=NULL) /*如就绪队列不空*/
  ; c! m# f2 e  a; E! g
  
• 
  
           {  
  
  
• 
  3 z" t  v. F2 t( L
              firstin(); /*将就绪对列的第一个进程投入运行*/  
  
  - [) W5 l# t' P5 `2 Z+ y
• 
  * B4 d) z) _7 O1 H
    x% D0 ?! R5 e1 C5 l" X# T         }
  
  
• 
  
        }  
  ! J% T, j9 v* R3 Z' y5 b+ z8 F
  
• 
  ; [! X5 \: p6 r- A: ]& n$ f; o* S
  9 g7 o& ?  S0 E4 G8 {4 x$ v$ y% y      else /*没有运行完同时优先数不是最大，则将其变为就绪态插入到就绪队列*/  
  / L% }- |! l" J( N9 u, Y
  
• 
  9 D, E8 D2 t2 D5 E7 w# X( y; q
       if((ready!=NULL)&&(run->prio<ready->prio))  
  
  
• 
  
       {  
  
  
• 
  8 I% \& P' M7 g) h
  , `# W. A. D4 H3 L: u6 s/ V9 J        run->state='W';  
  
  # l, Q- P# ^; f+ [/ Y3 D
• 
  
          insert1(run);  
  8 N& N3 t7 j# c2 @
  ( |2 ^4 S" |0 I, r
• 
  4 _( h8 `8 @$ C9 M- [
  7 e! |) J* V' y0 F! y" R" m. k        firstin(); /*将就绪队列的第一个进程投入运行*/  
  
  
• 
  
       }  
  5 u7 z- [' u  `# K/ j" V* J$ e
  
• 
  . S, |3 L. H. [7 t1 z; X8 i
  6 W% o! ~& R7 L      prt(alg); /*输出进程PCB信息*/  
  5 l# V4 S6 H; J; m. Q4 P
  " B# a( t2 T4 G. ?6 A, n
• 
  2 p% |1 G) `& V* g+ E
     }  
  / c, `1 [4 l: s; H$ F% U" f! O
  
• 
  2 j) F- e' E( c
  }  
  + a7 [' ]9 J) P: y8 y3 a
  # k* ^: b# p. K9 P: ^  S
• 
  ; M3 }' X" \9 d' X
  # I" }' R) J3 r, K: r" ^: ]/*主函数*/  
  
    f& Q( R0 _$ M  p
• 
  0 q  D8 V0 K- b( w  v
  6 [) O- F1 J9 I. K4 D3 _main()  
  / M  ~3 d, X7 C7 Y; `
  ( _* [$ k% `9 d) k, J- K
• 
  7 M1 z% V" F$ Z' P
  {  
  
  
• 
  5 w3 k2 R- g' w4 f$ i* n0 ^3 K
  ! Z' `8 {  c4 t9 q. ?; G2 u   char algo;  /*算法标记*/  
  
  7 J- S: ^: {, `: \& Y4 E' B
• 
  ; U# g" ?0 Q2 g1 t4 m+ W9 J
     printf("输入P确定算法：优先数算法\n");  
  
  / C- b" D. q/ _- F" |! I; S
• 
  ; {' ~2 d' W; F1 l- L# A! Q
     scanf("%c",&algo); /*输入字符确定算法*/  
  0 k1 v8 ]8 e. s; |: K
  # a8 M; y$ N& h: K/ p/ A
• 
  + f- x+ C. u$ k8 v
  $ E6 p5 Q2 v+ m7 H. [# S2 X+ R   printf("输入进程数：\n");  
  
  
• 
  
     scanf("%d",&N); /*输入进程数*/  
  & h8 i4 T2 j% E5 M' A
  , [* Z3 R7 L& S1 ^" _
• 
  ' g4 G9 q( f" ~/ i
     if(algo=='P'||algo=='p')  
  
  
• 
  " H5 `/ l, S* a9 Z
  3 w* O% h) n$ B2 P   {  
  3 s) z. h2 l; Q3 ^& K; Y1 R
  ) R3 T( I0 U; m% _9 T
• 
  & k& A" C, L5 r0 v/ i
        create(algo); /*优先数法*/  
  
  ! @2 R6 G6 u$ R7 X' k, }
• 
  
        priority(algo);  
  ' v8 q) j; t7 ]) l& ^
  
• 
  
    c7 `& h3 t: v! n4 ]   }
  ' v. B% k5 r( t. O
  
• 
  5 p& S" ?- C8 o! m% M8 o% W( |
  / w  c. R8 Y% Q% Q0 ]' p}
  
  , h( p+ O+ _8 n4 Y! x4 v& w" L0 N
  

输出结果：

) X0 T! B% h5 t; b原文：https://blog.csdn.net/weixin_40962955/article/details/80072769

1 X) d4 w- e; ]8 A$ h7 |7 Q& |
2 G. N2 _4 i  z4 m+ t" R