数学建模社区-数学中国

标题: 优先级调度算法 [打印本页]

---

作者: 杨利霞    时间: 2021-4-9 15:39
标题: 优先级调度算法

- h* Q! Y# ^& B1 o6 F9 U3 p优先级调度算法

算法介绍
" F2 O( v2 _1 i* c4 S优先调度算法的类型（用于作业调度）
7 A% }8 W( k5 I7 f1）非抢占式优先权调度算法
. |/ J% z  T* d) |- G/ G2 {4 P系统一旦把处理机分配给优先权最高的进程后，便一直执行下去，至完成。
2）抢占式优先权调度算法
* S: N; u' M0 V$ c. @. x. U6 `只要系统中出现一个新的就绪进程，就进行优先权比较 。若出现优先权更高的进程，则立即停止当前执行，并将处理机分配给新到的优先权最高的进程。

优先权类型
1）静态优先权
# m7 ]2 ?) t5 W' f% q静态优先权在创建进程时确定，且在进程的整个运行期间保持不变。
/ I# Q6 F2 W8 T

2）动态优先权

算法实现

抢占式动态优先权：

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

• 
  7 j0 z2 C/ d1 a/ L, B+ b: \! z
  * q+ ?6 o8 F4 J3 _0 a7 e& z2 v#include <stdio.h>
  
  1 e* t' N! x9 k7 i* `( J- r6 m
• 
  
  ) U# K& R& x1 V! C4 T: A& |#include <stdlib.h>  
  1 V+ n/ T; E0 d; Q
  0 z! O9 S% T3 S
• 
  
  ; |  K0 Y5 z1 T1 g  {- A! X/ C#include <string.h>  
  
  
• 
    I! g9 y; y$ g6 s- z  o
  % S. a' V# b4 [9 ?typedef struct node  
  6 H4 x* W4 u( z; P# J% g9 n6 I
  
• 
  
  * ^/ P! X9 Y" I4 m( \/ H{  
  $ _2 P6 a! x5 V  {8 D" `: J
  ! ~! ?' D% u, V2 p! z# `% c
• 
  3 M5 l5 l9 r5 D5 p0 R6 }1 S
     char name[10];  /*进程标识符*/  
  
  ) `. W2 b. Y3 {; a; e6 p3 l& ^" r% n3 ]
• 
  
  9 \7 J- i' T) V) W   int prio;   /*进程优先数*/  
  ) v8 h8 x9 b7 d$ y
  
• 
  9 n6 J+ ~* s+ S( C
     int round;  /*进程时间轮转时间片*/  
  
  
• 
  6 {. |# s3 ~& j0 `$ h& W# X
     int cputime; /*进程占用CPU时间*/  
  
  2 }! W* a5 `. \/ p
• 
  ! a* H9 D6 T% j# b
     int needtime; /*进程到完成还要的时间*/  
  ) F+ _5 Z  Z' a) V
  
• 
  
     int count;  /*计数器*/  
  
  0 p" m4 V$ v* s1 w. h9 c* {5 o( S
• 
  % l' I( x; R- y. e/ l; C$ B
     char state; /*进程的状态*/  
  
  
• 
  
     struct node *next; /*链指针*/  
    w4 x2 f8 e' i- G" f! G
  
• 
  
  }PCB;  
  3 [9 u- s+ w6 w6 t) `
  
• 
  
  5 M# @- n( o! G1 _# OPCB *finish,*ready,*tail,*run; /*队列指针*/  
  ( \) [4 q( G$ F" B: o% [
  , G( d7 J% V, n$ d% c  h0 f' I
• 
  
  int N; /*进程数*/  
  - a. a9 c5 T0 [) O: e4 w+ Y# A
  + q. R# e$ L, p9 l
• 
  : Z! c/ r# p; Z; z% n- A% J
  5 A* f$ {8 H  w# A# _/*将就绪队列中的第一个进程投入运行*/  
  ; h0 |4 h) o9 k! j7 ]  m
  $ i/ ?3 Y( V/ g2 G" k
• 
  
  firstin()  
  : |* D/ L1 q& X% z2 R
  
• 
  
  5 i1 a8 B) j/ ]* `8 P1 ]{  
  - ^5 l# f$ x- W9 D; p
  
• 
  
    o) f/ d6 p2 A3 y) \   run=ready;   /*就绪队列头指针赋值给运行头指针*/  
  
  
• 
  
  4 s( C& Q) \" Y, y% J   run->state='R';   /*进程状态变为运行态*/  
  
  
• 
  
  * M* G. n3 ]6 v2 Z& A   ready=ready->next;  /*就绪对列头指针后移到下一进程*/  
  
  5 ~. ?9 R# D. x9 t# U5 _5 c. u
• 
  & X+ i- Q+ w0 j" K& i  U
  % `) s+ @% D4 P' c! }& e+ K' A}  
  
  1 Y* a  v& i; \
• 
  1 y/ @& Z+ G% c% {, f8 q" P
  $ h/ {4 E* p8 u5 s1 ]' G4 |, j/*标题输出函数*/  
  
  9 m- }# D9 g- T- j
• 
  
  ; y3 n+ r4 ~/ q% o5 K3 Y8 uvoid prt1(char a)  
  
  & P& v) A3 p, ^' j
• 
  
  {  
  
  2 v7 Q4 z  Y  _7 g
• 
  
  2 H8 B6 P% S- g4 |% g   if(toupper(a)=='P') /*优先数法*/  
  
  
• 
  , j; J; N0 P/ C' M- \; b( O
        printf("  进程号   cpu时间  所需时间  优先数    状态\n");  
  
  
• 
  
     else  
  ' y* C& }* l# `
  % o' C1 z# g! I! \& c4 R0 W
• 
  
        printf("  进程号   cpu时间  所需时间   记数   时间片       状态\n");  
  + t5 o1 n2 Z( p4 E% a" e
  
• 
  0 ]" U" D. v: ]' }/ m! s
  3 U  Y. {6 g2 u* y! O}  
  
  
• 
  : S6 ~5 |) i* F' r% K  m
  ' d, w+ {9 s5 R( A$ P/*进程PCB输出*/  
  9 F9 G) E: }. G
  
• 
  
  * w2 C* H+ K+ @7 x+ D3 F0 ovoid prt2(char a,PCB *q)  
  
  
• 
  ; q+ {$ F; v( Y3 L
  ( Q1 c- h9 e5 T{  
  
  " _/ S7 P; _7 g+ j9 |) N; p% w
• 
  
     if(toupper(a)=='P')  /*优先数法的输出*/  
  
  + p+ j5 q+ G4 j- T& a
• 
  9 C: k; I* }; R- Y5 G" U
  : E  P, E+ r) y" Q' F& ^6 M: i, |, X% H      printf("  %-10s%-10d%-10d%-10d %c\n",q->name,  
  - c& n  t& @3 G
  
• 
  
         q->cputime,q->needtime,q->prio,q->state);  
  + r% s4 n/ h+ r$ C: |' l2 O* W
  
• 
  
  9 w9 m' Q6 W/ q: m- Y   else/*轮转法的输出*/  
  " F9 m0 K. d( ?0 r- q# u( q
  
• 
  ! }# E) R7 M* n
  ; s4 {2 w% M) U. `7 o5 N$ q. _      printf("  %-10s%-10d%-10d%-10d%-10d %-c\n",q->name,  
  ( X+ N1 _1 I. c% ~. I$ w- C$ `
  
• 
  8 D. o' g  l5 k# i. Q+ l* z6 s# R
         q->cputime,q->needtime,q->count,q->round,q->state);  
  ' o6 l( V0 Y; J. Z: D: y, L
  
• 
  ! K: R& q# B' }* I; O' V
  }  
  
  4 c( P8 b7 k+ v* B
• 
  1 H4 B' W3 c7 D* j4 Z3 p
  & {0 E  R2 r. Y4 s7 m: W/*输出函数*/  
  
  
• 
  
  void prt(char algo)  
  
  
• 
  
  {  
  , l6 S0 d' ?4 r  S
  
• 
  
  2 X+ X% p+ L: m   PCB *p;  
  2 O3 b& d8 [5 r. b5 o" _1 T7 @  s
  
• 
  , q, W' c, H) p* u+ X$ `8 Y
     prt1(algo);  /*输出标题*/  
  
  
• 
  
     if(run!=NULL) /*如果运行指针不空*/  
  + u) z2 R" J- G; l$ V6 @
  
• 
  5 {3 s& R) g* M
        prt2(algo,run); /*输出当前正在运行的PCB*/  
  : n4 u" f: S+ b4 J0 ~7 V
  
• 
  
  1 P; J* @7 Q( J$ n   p=ready;  /*输出就绪队列PCB*/  
  / f* k' z- P/ }% E: ~! P- j
  ) e  R, s# U. p9 O  @8 h. u
• 
  
  ) J8 \3 a2 e3 E) ^: S% K, _   while(p!=NULL)  
  " z5 @) U* }( u7 {1 p& H+ d
  ( D! {! g  x, h
• 
  
     {  
  ! i" ?  c7 U) _8 l  c
  
• 
  3 I9 N2 R% k0 G3 e: ~! K
        prt2(algo,p);  
  1 V+ D2 `1 l4 b0 ]7 s; |2 R
  / l" S. [0 I; @/ C6 m) h# x8 f
• 
  7 o, @4 G% p% e* a5 v: S
        p=p->next;  
  , F8 Q2 p3 P8 p6 f- g
  ( O7 R; ^; K4 E5 g% a. g7 O; T0 z4 B
• 
  
     }  
  
  
• 
  8 H( b- H9 P7 Q2 r
  . g6 P# S  Q4 I$ C( A, `   p=finish;  /*输出完成队列的PCB*/  
  7 R: Z7 v8 t  D$ J2 D1 T. a" W
  
• 
  
  9 J( C) K" S6 w) j   while(p!=NULL)  
  
  
• 
  
  4 j# O. P3 @+ P  \* F9 G3 d! x   {  
  
  
• 
  6 _0 p) Y+ i- o7 ?4 G8 M9 \
        prt2(algo,p);  
  ' U- o0 [* m$ Y3 c) _
  
• 
  0 V* i) R! _4 w% A0 w% J. t
        p=p->next;  
  
  ! z  S/ Y) I& v: A$ R+ ~
• 
  . `" e- I7 a& x1 \9 X. \
     }  
  
  " a' c( u/ {/ d
• 
  
  ' E2 ~) w7 E1 g1 |0 h   getchar();  /*压任意键继续*/  
  $ c2 B8 F1 V, ?$ S, @) h
  * E* S  v5 D6 r5 _
• 
  + z7 ~& l7 B/ A4 k
  }  
  % G: L: ^' K- v( U/ Q. x7 f9 v3 g& H
  
• 
  
  /*优先数的插入算法*/  
  
  " V6 H( ^) [8 c1 o# p& ?( C
• 
  
  insert1(PCB *q)  
  
  
• 
  7 L1 }2 ~4 V& r; V; \( N
  * Z3 u, a0 U+ O8 H{  
  / K+ p! y* Z" P  n5 D+ D8 W: K0 O
  ! y' u" Y* [0 l# I
• 
  
  5 S' ]. v; }) n) H% i   PCB *p1,*s,*r;  
  
  
• 
  ; ~* e2 i0 a- ^) [9 L( L" J
     int b;  
  7 `  H1 [  a- C8 V
  $ N+ p: V* M4 z" X2 v! R
• 
  , Y% E' d8 R! r- {$ \& G
     s=q;  /*待插入的PCB指针*/  
  
  - C7 S6 F" }1 Q7 g  l
• 
  
  : t; Q5 _) b. k* `0 u9 s   p1=ready; /*就绪队列头指针*/  
  
  " k+ A$ K! f2 W! f5 _1 A
• 
  2 ^6 ~" E6 f- i8 U! N( t( m
  " B3 k* V  u2 Y3 W   r=p1; /*r做p1的前驱指针*/  
  
  
• 
  
  6 D3 W+ L9 }( j* A8 k/ U   b=1;  
  ; C$ u! S* j; Z; i- M  Z  n/ }" S/ K5 e
  , h8 |* `6 q3 }" S, U" _  f3 F
• 
  
     while((p1!=NULL)&&b)  /*根据优先数确定插入位置*/  
  
  
• 
  
        if(p1->prio>=s->prio)  
  
  
• 
  + |8 Y1 k. W. n( x" e
  " I) D8 v5 r6 C2 ]      {  
  
  
• 
  & ]- p3 z4 H* t8 q
  + k" N" j8 k- e# p: }( |     r=p1;  
  2 X. U' W3 v+ @- L" X- [
  7 R4 j  s: K$ t. k
• 
  
  ' s( \4 d1 A5 G" i8 U% v6 f6 L     p1=p1->next;  
  " n5 N  C7 a) b" {% X0 f0 ~; w7 R
  
• 
  8 m  Q; |; ^* Y  ^7 X
  ; a4 x4 x. a+ a( E      }  
  * z) P' ?3 k# [2 z' E
  
• 
  
        else  
  ; O+ |0 t6 E8 B' }- \
  
• 
  * A7 R1 \; Z+ ?0 P: e) z
  ! p0 v1 h/ a3 o- B     b=0;  
  
  5 ~$ x! u' e( Z/ @4 u9 H: k5 X
• 
  
     if(r!=p1)  /*如果条件成立说明插入在r与p1之间*/  
  
  
• 
  3 [* `. o1 A5 Q0 l+ {
     {  
  ; z; y: j4 c3 [+ I5 V+ B
  3 A5 J: y) n/ H0 Z6 B
• 
  5 g8 e1 V( |  H6 J6 @5 M2 ~$ U
  & r! F2 ]+ N5 |- p% j      r->next=s;  
  3 H; D# D, N* X$ b7 Y
  $ S0 c1 H" @# L' h- I3 c/ m
• 
  1 }& ~7 I( J  o: k
  , T/ n. c& [. p+ e      s->next=p1;  
  1 t1 m- _- I2 n
  
• 
  
     }  
  1 g" N* S# t9 J& T
  
• 
  + j5 ?7 \, j/ N% |/ o- u9 q" X1 ?
     else  
    C* p- F2 o+ d9 R2 B1 `
  , E: q6 e/ x1 X5 L
• 
  
     {  
  
  - N- v  G5 J  d. j
• 
  ! [+ i2 w  n$ ]% Z7 K* N* N- k
        s->next=p1;  /*否则插入在就绪队列的头*/  
  
  - @$ _$ `6 V3 ^. Q, f
• 
  
        ready=s;  
  
  
• 
  3 l+ C0 ^. t9 N. w" Z/ R$ v: o
  ' z+ a# j- w; y   }  
  
  
• 
  # p; d& n8 c: A) n( n
  }  
  
  
• 
  
  , H" [! s! o5 T. O, r/*优先数创建初始PCB信息*/  
  4 F' C5 d8 J) Y2 |% E2 f
  - |0 X- o# o# Q3 \( e
• 
  2 g% J6 @* o# M7 {, t
  1 G' Y" t2 e+ G! h, `8 Rvoid create(char alg)  
  - q- a3 }7 o0 f+ ~+ N6 m5 Z* o+ w; F
  $ Z4 a1 U: }+ i( S
• 
  , Z! ]" T2 z/ I8 t& f: l
  {  
  
  
• 
  
     PCB *p;  
  
  
• 
  $ K; B$ I9 l  y0 N0 n, o% Z
  : n- L3 v! O/ V   int i,time;  
  
  
• 
  
     char na[10];  
  
  / b' j! H/ B6 }7 P
• 
  4 @6 Z& b: D: A- k3 L" e8 A+ C9 K
     ready=NULL; /*就绪队列头指针*/  
  
  
• 
  
     finish=NULL;  /*完成队列头指针*/  
  
  + I3 ~" x, S+ L* \
• 
  1 {# w4 d7 K* v6 E
  7 F8 f& x; I) u. K' V   run=NULL; /*运行队列指针*/  
  ; g4 c6 B( w3 X- W1 ?, C( c9 b
  
• 
  " C. f, N$ U+ |8 F  x* l
     printf("输入进程号和运行时间：\n"); /*输入进程标识和所需时间创建PCB*/  
  
  
• 
  
     for(i=1;i<=N;i++)  
  
  
• 
  % K" s" p4 r% K# `4 w3 }
     {  
    Z& `6 N6 S) n7 g4 q; ^
  
• 
  6 c3 h) V1 k! B* l3 p
        p=(PCB *)malloc(sizeof(PCB));  
  
  ! m8 S$ J$ M( u8 D# l
• 
  
        scanf("%s",na);  
  
  
• 
  1 t+ a  B7 O4 b5 O% N
        scanf("%d",&time);  
  . D* M; _" ^2 `1 ^5 B; g8 H
  9 |. {, J( g, Q8 H2 G. q
• 
  
  5 K3 n4 x. @. R" `, n      strcpy(p->name,na);  
  
  
• 
  
  + ?# i! E  O( d( u, w' [. `; [      p->cputime=0;  
  
  - V* X( m& ^8 `& F' e: r$ E, i
• 
  
  $ A6 q' o, M* n  r      p->needtime=time;  
  
  1 v7 b6 d5 b8 v! N6 k
• 
  
  7 h' [# q3 n& \1 A6 s      p->state='w';  
  
  
• 
  % ^! E' u+ t/ y2 ~, n
  5 v+ W+ q. M8 t( T      p->prio=50-time;  
  6 p( o$ T; b- a: E
  
• 
  
        if(ready!=NULL) /*就绪队列不空调用插入函数插入*/  
  ; R2 S0 P1 h% I5 }$ j! p. }/ _
  
• 
  
  & |2 l9 \) m; M# N$ C5 G     insert1(p);  
  
  
• 
  
  " a, n6 ?" y6 Q1 Z      else  
  * J6 Y2 t  u9 z, t: F
  
• 
    ^% n( s6 i: p8 u  O, R
  , W" y- @  y# B/ |! z      {  
  
  
• 
  " b! q# v7 N9 d
  " C  K3 p" k1 [* c     p->next=ready; /*创建就绪队列的第一个PCB*/  
  
  
• 
  
  4 h# E" G$ {) r) @: U     ready=p;  
  
  
• 
  & S6 y' S8 q5 G4 |4 u8 p
  4 G  m* n! G; Y9 d, j5 d4 ~      }  
  : w8 `4 P* {/ V/ D
  ( {1 \7 g1 E+ [1 _$ J$ {0 C! i5 r
• 
  
     }  
  - H& N; U9 ?/ B3 R2 |
  
• 
  ( d, Y' u) u8 E$ N- u: O
  5 n% V: c3 _/ s$ _: y   printf("          优先数算法输出信息:\n");  
  
  
• 
    z( D6 A5 y* c1 D) M/ i% m+ ~# j; |
     printf("************************************************\n");  
  
  ! i  [4 m  |0 l2 u8 X( P" |. `. M/ H
• 
  
  + j6 r! D/ B) X! E   prt(alg);  /*输出进程PCB信息*/  
  - j* |3 Q8 ]0 \' @8 ?# X) ^# U/ o7 c9 {
  # b; Y0 g0 g! \9 E, i
• 
  
     run=ready; /*将就绪队列的第一个进程投入运行*/  
  
  7 n: t* G+ G1 e) b) f
• 
  
  8 W2 [% _5 `- x7 {& Y% D3 a: m" M   ready=ready->next;  
  
  
• 
  
  2 C! M  A- V$ d9 G   run->state='R';  
  
  6 f5 u+ z) @, m: B) M* }5 y
• 
  
  }  
  7 k3 a% E$ A8 H) z; k* r" t* @: Y- G
  
• 
  
  /*优先数调度算法*/  
  
  2 f/ J4 g' L5 A
• 
  
  priority(char alg)  
  
  " z" e4 r: G. q' `  E6 O
• 
  ! o, P- y4 b+ p+ A
  {  
  
  
• 
  ! F+ g( U$ f- ^7 T
  1 Z+ G+ C, G1 d: T) ~   while(run!=NULL)  /*当运行队列不空时，有进程正在运行*/  
  4 K! G/ \- ~0 m4 {
  
• 
  9 D  E. Y) h" v; e" F
  ! e. P7 y3 n0 M( [" q# ?2 U   {  
  
  
• 
  
  4 V; e' {! U& Z/ q( b+ X      run->cputime=run->cputime+1;  
  
  ; N; ?7 D$ ^+ C$ b* O
• 
  
        run->needtime=run->needtime-1;  
  % ]1 v' _/ T& @2 J, v! N+ Y+ y! j( @
  
• 
  
  ( q- s# e! t4 x0 ]1 Y      run->prio=run->prio-3; /*每运行一次优先数降低3个单位*/  
  
  
• 
  
        PCB *p;
  $ h  L1 h1 u5 p- ]# {# @) x! N4 \
  
• 
  - r' K4 a* A( D4 _& H" w. Y
  8 a$ \. T& j: a! V; v      p=ready;
  
  ) g/ i3 w  u3 a8 E, @) d
• 
  
        while(p!=NULL)  
  
  $ P8 w# n8 K* T; X7 P0 E
• 
  / B: ?. q9 f1 l6 \8 s) ?* C
  $ O5 l! j0 h& h9 J* D" V      {  
    w6 @+ Z$ `6 g1 \; Q
  - N: N/ Y. |: V3 A) U
• 
  
  ! b" P4 h: K9 }          p->prio=p->prio+1; /*每等待一次优先数升高1个单位*/   
  5 B2 ~8 {. S1 Y, ]
  ) U- u* {( v% ^& p7 r7 F% G
• 
  
            p=p->next;  
  - h2 {1 e* M& y0 V
  
• 
  
        }  
  5 D5 X" D! [; t4 S1 V& I8 K
  ) b# a" @. ^" o) o/ j' C
• 
  
        if(run->needtime==0)  /*如所需时间为0将其插入完成队列*/  
  6 ]* k, G- ^% Y  \9 O& Q  L
  " k0 ~% n: m, E* H1 S7 n" ~* W) m  w( j
• 
  3 X2 v' e# r4 e4 ~/ m2 I
        {  
  * G7 y9 q$ B  I0 D' o2 K9 o
  9 ^' }1 [* f% L' g" u9 Q' `; J" W
• 
  
  6 a) d+ T0 S/ X$ w  H; R         run->next=finish;  
  ' y. b: _0 u! O
  " J( ~6 r! z- g2 a! D( G) ?
• 
  
  ! o) s6 M3 i' k" q1 h7 F         finish=run;  
  
  ' d4 `# r- ?' Z( e6 Z
• 
    Q5 K' o9 j1 d- \! }
  : g# u& l2 W- m$ x* E- n         run->state='F';  /*置状态为完成态*/  
  
  
• 
  
  + X- [$ i8 B6 K" d         run=NULL;  /*运行队列头指针为空*/  
  " B& ~1 c. {( Y/ }
  
• 
  , w% y( q6 H& n/ B
  & U, Y9 u/ j/ C) s9 M; i! K2 j6 O         if(ready!=NULL) /*如就绪队列不空*/
  " V/ x8 X: e. h7 r/ a5 }  d; J
  
• 
  
           {  
  
  
• 
  
  2 S! j) l5 D+ }0 o            firstin(); /*将就绪对列的第一个进程投入运行*/  
  
  2 p# G/ Q: |7 s; N4 ?; c/ F2 _
• 
  
           }
  $ }# Q* K' l) ]' A1 h9 N
  
• 
  / X( s! `4 o7 P, m  @3 J
  : F6 ?2 m( Y/ v+ U7 m5 q      }  
  ! R* N% M0 q2 y6 P! t1 B
  
• 
  
        else /*没有运行完同时优先数不是最大，则将其变为就绪态插入到就绪队列*/  
  # t- D# g0 P8 e- M8 I% ~0 E
  / Z! s3 w% I1 X  I+ Y
• 
  
       if((ready!=NULL)&&(run->prio<ready->prio))  
  # ?1 ^6 R7 V+ c0 w, S  @5 s
  % t; `2 o; y$ u9 t$ @9 G
• 
  
  ( v$ O3 y% w* M% ~8 h+ p     {  
  
  
• 
  
          run->state='W';  
  
  
• 
  
          insert1(run);  
  8 X. N# ^5 x! ?! d4 s; O
  
• 
  % X: N; P7 g3 O' z
          firstin(); /*将就绪队列的第一个进程投入运行*/  
  5 g5 S: M. J8 w& A% `, W
  
• 
  
       }  
  
  
• 
  ' \/ w  Z: P  `! q+ F
        prt(alg); /*输出进程PCB信息*/  
  9 B9 o5 [8 K1 m& Y6 W  i
  & H# W+ ~- Z- v1 ?; I/ G+ `
• 
  
  / ^) O. R6 I2 b# I   }  
  
  
• 
  - F* O0 }& t0 q) ~3 o" b
  }  
  : Y' H  h* w6 x* F0 w5 Z
  
• 
  
  /*主函数*/  
  
    Z, S, M) d- B6 U% T
• 
  # I' v& ?/ Y; k4 n, J$ M
  main()  
  + N7 S5 P. i1 b/ `
  
• 
  
  {  
  8 K6 T1 a2 R! S- E+ C9 i5 y
  0 Q+ l5 v1 P; h5 ?# g$ i# y: B8 ^( @
• 
  
  9 C7 n: Y0 }1 I   char algo;  /*算法标记*/  
  ; O' R# d/ m/ ?8 a7 h0 @" E: J
  
• 
  
  3 E. T  |( U9 V& C   printf("输入P确定算法：优先数算法\n");  
  : Z3 V3 U, `+ i; F' L
  
• 
  
     scanf("%c",&algo); /*输入字符确定算法*/  
  - `9 s, G. u( E# _# z( f# b, t
  % |" t+ O& `+ h% Z3 y; \1 V+ ]
• 
  
     printf("输入进程数：\n");  
  
  
• 
  9 g' Z$ |+ t& a! H$ x
  * L1 M1 k% K: Y; C   scanf("%d",&N); /*输入进程数*/  
  ! P, @2 h& ?6 @5 F
  . w1 P* h/ H- d& j7 x1 u
• 
  
     if(algo=='P'||algo=='p')  
  # |# V* P( S2 k3 f
  2 u; A7 W7 B% V
• 
  7 f3 v/ r' x$ d1 ?% T
     {  
  ) u7 H0 P. V- t
  / Z: Z3 Z8 C0 ]) x, N6 u$ A' Q
• 
  * y/ Z3 k! [  P) c/ o2 F" p3 _
  & V& d+ o% r5 k% ]$ N6 ~      create(algo); /*优先数法*/  
  , c- b( I& X0 U4 p/ j* c
  
• 
  
        priority(algo);  
  " H+ w, Y, ?* Q  j  N
  
• 
  
     }
  $ {( j, [& `; t2 Q
  
• 
  
  * p1 c* [" \$ g9 x: e}
  $ N1 r! `! `6 N* Z
  * X8 i" X3 u7 B  `' r: j* h; ^
  

输出结果：

! b% U. F4 ]3 G/ y原文：https://blog.csdn.net/weixin_40962955/article/details/80072769

) U+ \& L9 U# M# O/ J8 Z

---

欢迎光临 数学建模社区-数学中国 (http://www.madio.net/)

Powered by Discuz! X2.5