操作系统实验 批处理作业的调度算法

#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>
#include <cstdlib>
#include <vector>
#include <algorithm>

using namespace std;
typedef pair<int, int> pii;
const int N = 10000;
int num;

struct Node {
	char name[30];//作业的名字
	int cTime;    //作业进入输入井的时间（以分计）
	int rTime;    //作业的运行时间<以分计算>
	int sTime;    //作业开始运行的时间
	int eTime;    //作业运行结束的时间
	int tTime;    //作业周转时间
	float circle; //带权周转时间
}jobs[N];

bool cmp1(Node i, Node j) {
    return i.cTime < j.cTime;
}

inline int max(int a, int b) {return a > b ? a : b;}
inline float fmax(float a, float b) {return a > b ? a : b;}
void FCFS();
void SJF();
void HRN();
void input();
void output();

int main() {
    //freopen("Test.in", "r", stdin);
	int op;
    printf("*****************************\n\n");
    printf("    欢迎体验作业调度算法\n\n");
    printf("      1.先来先服务\n\n");
    printf("      2.最短作业优先法\n\n");
    printf("      3.最高响应比算法\n\n");
    printf("      0.退出\n\n");
    printf("      请输入作业的个数 ");
    scanf("%d", &num);
    input();
    while (1) {
        printf("      请输入你的选择： ");
        scanf("%d", &op);
        switch (op) {
        case 0: exit(0);
        case 1: FCFS(); break;  //跳转到先来先服务算法
        case 2: SJF(); break;   //跳转到最短优先服务算法
        case 3: HRN(); break;  // 跳转到最高响应比算法
        default: printf("\n     选择无效\n\n");
        }
        output();
    }
    fclose(stdin);
	return 0;
}

void input() {
    printf("请输入作业的名字和进入时间和估计运行时间:\n");
    int a, b;
    for (int i=0; i<num; i++) {
        scanf("%s%d:%d%d", jobs[i].name, &a, &b, &jobs[i].rTime);
        jobs[i].cTime = a*60 + b;
    }
}

void output() {
    printf("*******************************************\n");
    for (int i=0; i<num; i++) {
        int a = jobs[i].cTime / 60;
        int b = jobs[i].cTime % 60;
        int c = jobs[i].sTime / 60;
        int d = jobs[i].sTime % 60;
        int e = jobs[i].eTime / 60;
        int f = jobs[i].eTime % 60;
        printf("%s %02d:%02d %02d %02d:%02d %02d:%02d %02d %.2f\n", jobs[i].name, a, b, jobs[i].rTime, c, d, e, f, jobs[i].tTime, jobs[i].circle);
    }
    printf("*******************************************\n");
}

void FCFS() {
    sort(jobs, jobs+num, cmp1);
    int nowTime = jobs[0].cTime;
    jobs[0].sTime = nowTime;
    jobs[0].eTime = nowTime + jobs[0].rTime;
    jobs[0].tTime = jobs[0].eTime - jobs[0].cTime;
    jobs[0].circle = float(jobs[0].tTime) / float(jobs[0].rTime);
    for (int i=1; i<num; i++) {
        nowTime = max(nowTime+jobs[i-1].rTime, jobs[i].cTime);
        jobs[i].sTime = nowTime;
        jobs[i].eTime = nowTime + jobs[i].rTime;
        jobs[i].tTime = jobs[i].eTime - jobs[i].cTime;
        jobs[i].circle = float(jobs[i].tTime) / float(jobs[i].rTime);
    }
}

void SJF() {
    sort(jobs, jobs+num, cmp1);
    priority_queue<pii, vector<pii>, greater<pii> > pq;
    int index = 0;
    int endTime = -1;
    while (index < num) {
        pq.push(pii(jobs[index].rTime, index));
        while (!pq.empty()) {
            pii h = pq.top(); pq.pop();
            jobs[h.second].sTime = max(jobs[h.second].cTime, endTime);
            jobs[h.second].eTime = jobs[h.second].sTime + h.first;
            jobs[h.second].tTime = jobs[h.second].eTime - jobs[h.second].cTime;
            jobs[h.second].circle = (float)jobs[h.second].tTime / h.first;
            endTime = jobs[h.second].eTime;
            for (index++; index < num; index++) {
                if (jobs[index].cTime < endTime) pq.push(pii(jobs[index].rTime, index));
                else break;
            }
        }
        //index++;
    }
}

bool vis[N+5];
typedef pair<float, int> pfi;
void HRN() {
    sort(jobs, jobs+num, cmp1);
    priority_queue<pfi> pq;
    int index = 0;
    int endTime = -1;
    memset(vis, 0, sizeof (vis));
    int cnt = 0;
    while (cnt < num) {
        float r = (float)(endTime - jobs[index].cTime) / jobs[index].rTime;
        pq.push(pfi(r, index));
        while (!pq.empty()) {
            pfi h = pq.top();
            if (vis[h.second]) {
                pq.pop();
                continue;
            }
            else {
               pq.pop();
               vis[h.second] = true;
               cnt++;
            }
            jobs[h.second].sTime = max(jobs[h.second].cTime, endTime);
            jobs[h.second].eTime = jobs[h.second].sTime + jobs[h.second].rTime;
            jobs[h.second].tTime = jobs[h.second].eTime - jobs[h.second].cTime;
            jobs[h.second].circle = (float)jobs[h.second].tTime / jobs[h.second].rTime;
            endTime = jobs[h.second].eTime;
            for (int i = 0; i < num; i++) {
                if (jobs[i].cTime < endTime) {
                    if (!vis[i]) {
                        r = (float)(endTime - jobs[i].cTime) / jobs[i].rTime;
                        pq.push(pfi(r, i));
                    }
                }
                else break;
            }
        }
        index++;
    }
}