SRTF算法

#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>
#include <queue>
#define num 4
#define col 3
using namespace std;
int data[num][col] = {{1,0,120},
                      {2,50,50},
                      {3,60,10},
                      {4,110,20}
};
int n = 4;
const int INF=0x3f3f3f3f;
struct Progress
{
    int id;
    int arriving_time;//到达时间    
    int leaving_time;//结束时间
    int service_time;//服务时间
    int remaining_time;//剩余时间
    int cycling_time;//周转时间
    int dqzz_time;
    vector<pair<int,int> > start_end;//进程占用cpu运行的时间段，可能有多段
    void showInfo( )
    {
        printf( "progress:%d, arriving time:%d, leaving time:%d, service time:%d, cycling time:%d, start&ends:[ ",id,arriving_time,leaving_time,service_time,cycling_time);
        for( int i=0;i<start_end.size( );i++)
        {
            if(i!=0) 
            {
                printf(",");
            }
            printf( "(%d,%d)",start_end[i].first, start_end[i].second);
        }
        printf( " ]\n");
    }
    void showInfos( Progress p[])
    {
        for( int i=0;i<n;i++)
        {
            p[i].showInfo();
        }
    }
};

Progress p[1010];
Progress p_srt[1010];

bool cmp1( Progress p1,Progress p2)
{
    return p1.arriving_time<p2.arriving_time;
}
bool cmp2( Progress p1,Progress p2)
{
    return p1.service_time<p2.service_time;
}
bool cmp3( Progress p1,Progress p2)
{
    return p1.start_end[0].first<p2.start_end[0].first;
}
bool cmp4( Progress p1,Progress p2)
{
    return p1.id<p2.id;
}
void caculate(Progress p[])
{
    for(int i=0;i<n;i++)
    {
        p[i].leaving_time=p[i].start_end[p[i].start_end.size()-1].second;
        p[i].cycling_time=p[i].leaving_time-p[i].arriving_time;
        p[i].dqzz_time = p[i].cycling_time / p[i].service_time;
    }
}

void SRT( Progress p[])
{
    sort( p,p+n,cmp1);
    for( int i=0;i<n;i++)
        p[i].remaining_time=p[i].service_time;
    int t=p[0].arriving_time;//t为当前的时间，初始化为进程的最早到达时间
    int cnt=0;
    //cnt为已运行结束进程的数量
    while ( cnt<n)
    {
        
        int minr=INF;
        int x;
        for( int i=0;i<n;i++)//该循环找到到达时间小于等于t且剩余时间最短的进程，将其下标赋给为x
        {
            if( p[i].arriving_time<=t && p[i].remaining_time>0 && p[i].remaining_time<minr)
            { 
                minr=p[i].remaining_time;
                x=i;
            }
        }
        if( minr==INF)
        {//没有找到符合条件的进程，处理方法跟SJF里面类似（SJF函数里面不小心将一个变量命名为min，所以不能直接使用min函数 w(?Д?)w）

            t=INF;
            for( int i=0;i<n;i++)
            {
                if( p[i].remaining_time>0)
                {
                    t=min( t,p[i].arriving_time);
                }
            }
        }
        else//找到了符合条件的进程
        {
            int nextArriving=INF;//nextArriving为在t之后第一个新到达的进程的到达时间，初始化为正无穷
            for( int i=x+1;i<n;i++)//该循环作用是找到这个到达时间，并赋给nextArriving
            {
                if(p[i].remaining_time==p[i].service_time&&p[i].arriving_time>t)
                {
                    nextArriving=p[i].arriving_time;
                    break;
                }
            }

            if( nextArriving-t>=p[x].remaining_time)
            {//如果下一个进程的到达时间减去当前的时间>=现在这个进程的剩余时间，那么现在这个进程可以直接运行至结束。
                
                if( p[x].start_end.size()==0 || p[x].start_end[ p[x].start_end.size()-1].second!=t)
                {
                    p[x].start_end.push_back(make_pair(t,t+p[x].remaining_time));
                }
                    
                else 
                {
                    p[x].start_end[ p[x].start_end.size()-1].second=t+p[x].remaining_time;
                }
                t+=p[x].remaining_time;
                p[x].remaining_time=0;
                cnt++;
            }
            else//否则，现在这个进程只能运行到下一个进程到达，然后进入下一次循环，根据所有已到达进程的剩余时长，重新判断要执行哪一个进程。
            {
                if( p[x].start_end.size()==0 || p[x].start_end[ p[x].start_end.size()-1].second!=t)
                {
                    p[x].start_end.push_back(make_pair(t,nextArriving));
                }
                else
                {
                    p[x].start_end[ p[x].start_end.size()-1].second=nextArriving;
                } 
                   

                p[x].remaining_time-=nextArriving-t;
                t=nextArriving;
            }
        }
    }
    sort(p,p+n,cmp4);
    caculate(p);
}

int main( )
{   
    //cout<<"please input count of progresses:"<<endl;
   //cin>>n;
   int sum1 = 0;
   int sum2 = 0;
   double average_cycletime = 0;
   double average_dqzztime = 0;
    
    for( int i=0;i<n;i++)
    {
        p[i].id=i;
        p[i].arriving_time = data[i][1];
        p[i].service_time = data[i][2];
        cout<<"progress"<<i<<",display arriving time and service time: "<<endl;
        cout<<p[i].arriving_time<<" "<<p[i].service_time<<endl;
        
    }

    for( int i=0;i<n;i++)
      p_srt[i]=p[i];
    
    SRT(p_srt);
    cout<<"SRT:"<<endl;
    p_srt[0].showInfos(p_srt);
    for(int i=0; i<n; i++){
        sum1 = sum1 + p_srt[i].cycling_time;
    }
    for(int i=0; i<n; i++){
        sum2 = sum2 + p_srt[i].dqzz_time;
    }
    average_cycletime = sum1 / 4.0;
    average_dqzztime = sum2 / 4.0;
    cout<<average_cycletime<<endl;
    cout<<average_dqzztime<<endl;
 
    
    

}