进程调度——优先数算法

自己写的小程序，实验作业，有什么不对的地方还请高手指导啊啊啊啊-------------

#include<stdio.h>
#include<stdlib.h>
typedef struct process {
 int symbol;//进程号
 struct process *conn;//指向下一个进程的指针，但是饿哦写的程序中没有用到，只是赋了值
 int ordernum;//优先数，通过优先数排序决定进程占用cpu顺序，后面的程序中党两个进程优先数相等时，也要交换位置
 int cpunum;//占用cpu的时间，初值为0
 int neednum;//进程所需要执行的时间
 int state;//进程状态，1表示ready，2表示running，3表示over，初始化时为1
}pro;

void createpro(pro *p) {//此函数通过输入创建进程
 int sy, co, ord, cpu, nee, stat;//刚开始的时候输入写的比较复杂。。。
 printf("Symbol");
 scanf("%d",&sy);
 printf("ordernum");
 scanf("%d",&ord);
 printf("cpunum");
 scanf("%d",&cpu);
 printf("neednum");
 scanf("%d",&nee);
 printf("state");
 scanf("%d",&stat);
 p->symbol = sy;
 p->ordernum = ord;
 p->cpunum = cpu;
 p->neednum = nee;
 p->state = stat;
}
//另外下面注释掉的三个函数都是一开始不知道怎么给结构体排序写的。。。
/*
测试数据

1
12
0
3
1
2
9
0
4
1
3
6
0
2
1
4
3
0
3
1

*/
/*int reordernum(pro* p) {
 return p->ordernum;

}*/

void inorder(pro *p[], int n) {//进程根据ordernum进行冒泡排序
 int i = 0, j;
 pro *t;
 for (i = 0; i<n - 1; i++) {
  for (j = i + 1; j<n; j++) {
   if (p[i]->ordernum<=p[j]->ordernum) {
    t = p[i];
    p[i] = p[j];
    p[j] = t;
   }
  }
 }

}

/*void ordernow(pro *pp[], int n, int p[]) {
 int i = 0;
 for (i = 0; i<n; i++) {
  p[i] = pp[i]->ordernum;
 }
 将ordernum保存到p数组中，然后给p数组排序，然后再调用forder

}*/

void reorder(pro *p) {//进程执行时所做的动作，优先数减三，cpunum++，neednum--
 int t,c,need;
 t = p->ordernum;
 t = t - 3;
 p->ordernum = t;
 c=p->cpunum;
 c=c+1;
 p->cpunum=c;
 need=p->neednum;
 need=need-1;
 p->neednum=need;

}

int jud(pro *p) {//判断简称是否运行完毕，即是否运行了它所需要的时间
 int need,n;
 need = p->neednum;
 if (need ==0) {
  n = -1;
 }
 return n;
}

int delate(int n) {//将当前的可运行进程减掉一个
 n--;
 return n;
}

/*void forder(pro *pp[], int p[], int n,pro *pr[]) {
 int i = 0, j = 0;
 for (i = 0; i < n; i++) {
  for (j = 0; j < n; j++) {
   if (pp[j]->ordernum == p[i]) {
    pr[i] = pp[j];
    pp[j]->ordernum = -100;
   }
  }
 }
 是用来通过int数组将pp数组中的pro重新排序i并且存放到pr里面

}*/

void main()
{
 pro *p1 = (pro *)malloc(sizeof(pro));//分配空间
 pro *p2 = (pro *)malloc(sizeof(pro));
 pro *p3 = (pro *)malloc(sizeof(pro));
 pro *p4 = (pro *)malloc(sizeof(pro));
 int n = 0, coun = 0, judge,j,k,u,countnum;
 pro *pp[10];//存放可运行进程
 pro *gameover[10];//存放运行完毕进程
 //int p[10];原来用来存放ordernum
 createpro(p1);//设置每个进程具体参数
 coun++;//记录可运行
 createpro(p2);
 coun++;
 createpro(p3);
 coun++;
 createpro(p4);
 coun++;
 pp[0]=p1;//将初始化完毕后的进程存入数组中，其实可以直接赋值，不过最初是这样写的
 pp[1]=p2;
 pp[2]=p3;
 pp[3]=p4;
 judge = coun;//这个变量后面用来记录可运行的进程数，不过其实可以直接用coun
 countnum=0;//用来记录over的进程数
    char c;//调试用，可以删掉
    while(judge!=0&&(c=getchar())=='\n'){//可运行进程数不为0时进行循环
        inorder(pp,judge);//根据ordernum排序，因为ordernum的顺序不一定是1234的顺序，虽然测试数据是这样
        j=jud(pp[0]);//判断队首元素是否已经运行完，即neednum=0
        if (j == -1) {
                countnum++;
                pp[0]->state=3;//将状态设置为over
                gameover[countnum]=pp[0];//放入over数组中
                printf("process %d is over!\n",pp[0]->symbol);
                for(u=0;u<judge-1;u++){
                    pp[u]=pp[u+1];
                }//将该进程从可运行进程数组中删掉
                judge = delate(judge);//可运行进程数--
        }

           else//neednum！=0时
            {
                for(u=0;u<judge-1;u++){//给进程中指向下一个进程的指针赋值，只赋值coun-1个
                pp[u]->conn=pp[u+1];
              }
           printf("now!\n");//打印出未运行时pp0的参数值
           printf("cpunum = %d",pp[0]->cpunum);
           for(k=0;k<5;k++){
            printf(" ");
           }
           printf("neednum = %d",pp[0]->neednum);
           for(k=0;k<5;k++){
            printf(" ");
           }
           printf("ordernum = %d\n",pp[0]->ordernum);
           pp[0]->state=2;//将队首元素状态设为running
           printf("process========");
           printf("%d",pp[0]->symbol);
           printf("is running!\n");
           reorder(pp[0]);//改变运行进程的参数值
           printf("reorder!\n");//打印出运行后的参数值，可以对比发现变化
           printf("cpunum = %d",pp[0]->cpunum);
           for(k=0;k<5;k++){
            printf(" ");
           }
           printf("neednum = %d",pp[0]->neednum);
           for(k=0;k<5;k++){
            printf(" ");
           }
           printf("ordernum = %d\n",pp[0]->ordernum);
           printf("\n");
           if(pp[0]->neednum==0){//判断是否有进程运行完毕
            pp[0]->state=3;
           }
           else{
            pp[0]->state=1;
           }
           for(k=0;k<judge;k++){//打印出当前ready和over进程
            if(pp[k]->state==1){
                printf("process %d is ready to run!\n",pp[k]->symbol);
            }
           }
           for(k=0;k<judge;k++){
            if(pp[k]->state==3){
                printf("process %d is over!\n",pp[k]->symbol);
            }
           }
           printf("\n");
           }

    }

}

但是有一个问题。。。。。

此时已经判断1neednum=0，即处于over状态，但是它还处于pp【】数组中，没有从中删除并且进入gameover数组

此时1才从pp中删除，后面也是这样的情况。。。。。