操作系统——进程调度之短进程优先

#include "stdio.h"
#include <stdlib.h>
#include "string.h"
#define NULL 0

typedef struct pcb
{
    char name[10]; //进程名称
    int ArrivalTime; //到达时间 
    int StartTime;   //开始运行时间
    int FinishTime;  //结束运行时间
    int WholeTime;   //运行所需时间

    struct pcb *link; //下一个指针 
}pcb; 
int N;  //运行的进程数量 
void input();
pcb *ready=NULL,*p=NULL,*finish = NULL;  
//ready 是初始时的状态，finish 是结束时状态 
int M; 

void input()
{
    printf("请输入进程数量:");
    scanf("%d",&N);   //N为全局变量
    M = N;
    struct pcb *q = ready;
    int  i = 0;
    for( i=0 ;i<N;i++)
    {
        printf("请输入第 %d 个进程信息-----------
",i+1);
        p = (pcb *)malloc(sizeof(pcb));
        printf("请输入进程名：")    ;
        scanf("%s",p->name);
        printf("请输入进程到达时间:");
        scanf("%d",&p->ArrivalTime);
        printf("请输入进程运行时间：");
        scanf("%d",&p->WholeTime);
        p->link = NULL;
        if(NULL == ready)
        {
            ready = p;    
            q = ready;        
        }
        else
        {
            q = ready;
            while(NULL != q->link)  //将q移动到就绪队列最后一个进程 
            {
                q = q->link;
            }
            p->link = NULL;
            q->link = p;    
            q=p;
        }
        printf("
");
    }
    q= NULL;
    free(q);    
} 

//先输入的肯定是先到达的 
//nowTime 是现在执行的时间 
pcb* sjf(int nowTime,int *after)
{
    int i = 0 ;
    pcb *nowProgress=NULL, *p = ready;
    int ProgressNum = 0; // 当前最短的是第几个线程 
    int minTime =0; // 最短运行时间
    
    if(NULL != ready)
    {
        while(NULL != p) //遍历整个链表，查找出最短的进程，即运行时间最短 
        {
        //    printf("
%d  %d  %d  
",p->ArrivalTime,nowTime >= p->ArrivalTime,nowTime) ;
            if(nowTime >= p->ArrivalTime)
            { 
                if(0 == minTime)  //首次赋值 
                {
                    nowProgress = p;
                    minTime = p->WholeTime;                    
                }
                else
                {
                    if(p->WholeTime < minTime)
                    {
                        nowProgress = p;
                        minTime = p->WholeTime;
                    }
                }
                
                *after = minTime+nowTime;
            }    
            p = p->link;
        }
    } 
    
    return nowProgress;    
}

void output(pcb *p,int now_time)
{
    if(NULL == p)
    {
        printf("当前时刻：%d，暂无进程在运行！
",now_time);
    }
    else
    {
            printf("进程名：%s，运行时间：%d，到达时间:%d
",p->name,p->WholeTime,p->ArrivalTime);        
    }    
}

void outputAll()
{
    pcb *p = finish;
    printf("
-----------------------统计结果：-------------------
");
    float avgRevolve = 0;
    float avgSuperRevolve = 0;
     
    while(NULL != p)
    {
        avgRevolve += p->StartTime+p->WholeTime-p->ArrivalTime;
        avgSuperRevolve += 1.0*(p->StartTime+p->WholeTime-p->ArrivalTime)/p->WholeTime;
        printf("
进程名：%s,开始时间%d,结束时间：%d，运行时间：%d，到达时间:%d
",p->name,p->StartTime,p->FinishTime,p->WholeTime,p->ArrivalTime);
        p = p->link;    
    }    
        printf("
----这组进程平均周转时间：%f,平均带权平均周转时间：%f
",avgRevolve/M,avgSuperRevolve/M);
} 

// 删除准备队列（ready）已经运行的进程p ，添加到完成队列（finish）队列中 
void destory(pcb *p,int now_time)
{

    pcb *q = ready;
    pcb *f = NULL;
    if(strcmp(p->name,ready->name) == 0)  //第一个进程 
    {
        ready = ready ->link;
    }
    else  //中间进程 
    {
        q = ready;

        while(  (strcmp(q->link->name,p->name) != 0) && NULL != q->link)  //找到p要删除的位置 
        {
            
            q= q->link;
                
        }
    
        q->link = p->link;    
    
        
    
    } 
    
    
    
    
        //将已经运行的进程添加到finish队列 
        p->StartTime = now_time-p->WholeTime;   
        p->FinishTime = now_time;
    
        if(NULL == finish)  //第一个完成的进程 
        {
            finish = p;
            p->link = NULL;
        }    
        else  //中间完成的进程 
        {
            f = finish;
            while(NULL != f->link )    
            {
                f = f->link;
            }
            f->link = p;
            p->link = NULL;
        }
    
    

    
    N--;  //等待进程减1 
}

int main()
{

    input();

    struct pcb *s = ready;  
    int now_time = 0 ;
    struct pcb *nowProgress = NULL;  //当前运行的进程 
    int *after = 0; //执行完一个进程之后的时间 
    int i = 0 ;   
    
    pcb *m = ready;
    
    while(N > 0)//一次运行一个进程 
    {
        nowProgress = sjf(now_time,&after);
        
        if(NULL != nowProgress)  //当前有进程在运行 
        {
    
        for(;now_time < after;now_time++)  //输出每个时刻运行的进程情况 
        {
            printf("#################################################
");
            printf("当前时刻：%d
",now_time);
             printf("
-------------当前执行进程：----------
"); 
                 output(nowProgress,now_time);
                 printf("
-------------等待执行进程：----------
");
            m=ready;
            while(NULL != m)
            {
                if(m != nowProgress)
                {
                    if(m->ArrivalTime <= now_time)
                    output(m,now_time);
                }
                m= m->link;
            }
            printf("#################################################

");
        }
                    
            printf("
");

            destory(nowProgress,now_time); 
            
        }
        else   //没有进程在运行 
        {
            output(nowProgress,now_time);
            now_time ++; 
        }
                
    }            
    outputAll();
    return 0;
}