FCFS和SJF代码实现

#include <iostream>
#include <stdio.h>
using namespace std;

typedef struct job{
    int name;//作业编号
    int arrivetime;//到达时间
    int requesttime;//需要服务时间
    int finishtime;//完成时间
    int turnaroundtime;//周转时间
    int starttime;//作业开始时间
}JOB;

JOB job[100];
int jobnum;

void definition(){
    int num = 0;//定义系统总共的作业数
    int need,arrive;//分别定义所需时间和到达时间
    cout << "请输入作业的个数:" << endl;
    cin >> num;
    if(num < 0){
        cout << "输入非法,请重新输入!" << endl;
    }
    jobnum = num;
    for(int i = 0;i<jobnum;i++){
        cout << "请输入第" << i << "个作业完成所需时间和到达时间" << endl;
        cin >> need >> arrive;
        job[i].name = i;
        job[i].requesttime = need;
        job[i].arrivetime = arrive;
        job[i].finishtime = 0;
        job[i].turnaroundtime = 0;
        job[i].starttime = 0;
    }
}

void FCFS(){
    float avgturnaroundtime = 0;
    float aqtt = 0;
    cout << "此方法依据先来先服务原则" << endl;
    cout << "作业号 完成时间 周转时间 带权周转时间" << endl;
    for(int i = 0;i<jobnum;i++){
        job[i].finishtime = job[i].starttime + job[i].requesttime;
        job[i].turnaroundtime = job[i].finishtime - job[i].arrivetime;
        cout << "  " << i << "       " << job[i].finishtime << "         " << job[i].turnaroundtime << "         " << job[i].turnaroundtime/job[i].requesttime << endl;
        job[i+1].starttime = job[i].finishtime;
        avgturnaroundtime = avgturnaroundtime + job[i].turnaroundtime;
        aqtt = aqtt + job[i].turnaroundtime/job[i].requesttime;
    }
    cout << "作业调度次序:" << endl;
    for(int j = 0;j<jobnum;j++){
        cout << " " << j;
    }
    cout << endl;
    cout << "平均周转时间:" << avgturnaroundtime/jobnum << endl;
    cout << "平均带权周转时间:" << aqtt/jobnum << endl;
    cout << endl;
}

void SJF(){
    int nowtime = 0;
    JOB temp;
    float avgturnaroundtime = 0;
    float aqtt = 0;
    cout << "此方法依据短作业优先原则" << endl;
    cout << "作业号 完成时间 周转时间 带权周转时间" << endl;
    //首先判断第一个进程完成时是否有其他进程到达,并且比较他们所需运行的时间,选择其中最短的进行运行
    job[0].finishtime = job[0].arrivetime + job[0].requesttime;
    job[0].turnaroundtime = job[0].finishtime - job[0].arrivetime;
    nowtime = job[0].finishtime;
    for(int i = 1;i<jobnum;i++){
        for(int j = i+1;j<jobnum;j++){
            if(job[i].arrivetime <= nowtime && job[j].arrivetime <= nowtime){//当两个进程在这一时刻都已经到达,选取其中所需时间短的
                if(job[j].requesttime < job[i].requesttime){//将时间短的排到前面
                    temp = job[j];
                    job[j] = job[i];
                    job[i] = temp;
                }
            }
        }
        job[i].finishtime = nowtime + job[i].requesttime;
        nowtime = nowtime + job[i].requesttime;

    }
    for(int i = 0;i<jobnum;i++){
        job[i].turnaroundtime = job[i].finishtime - job[i].arrivetime;//周转时间
        avgturnaroundtime = avgturnaroundtime + job[i].turnaroundtime;//平均周转时间
        aqtt = aqtt + job[i].turnaroundtime/job[i].requesttime;//平均带权周转时间
        cout << "  " << job[i].name << "       " << job[i].finishtime << "        " << job[i].turnaroundtime << "         " << job[i].turnaroundtime/job[i].requesttime << endl;
    }

    cout << "平均周转时间" << avgturnaroundtime/jobnum << endl;
    cout << "平均带权周转时间" << aqtt/jobnum << endl;
}

int main (void){
    definition();
    FCFS();
    SJF();
    return 0;
}

 

  • 0
    点赞
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: 您可以使用Python中的collections模块来实现FCFSSJF作业调度算法。此模块提供了一个名为deque的数据结构,可以用来模拟堆栈,队列和双端队列。您可以使用这个数据结构来实现FCFSSJF作业调度算法。 ### 回答2: FCFS(First-Come, First-Served)是一种先到先服务的作业调度算法。该算法根据作业到达的顺序分配CPU的执行时间。 下面是使用Python实现FCFS作业调度算法的示例代码: ```python def fcfs(arrival_time, burst_time): n = len(arrival_time) # 初始化等待时间和完成时间数组 waiting_time = [0] * n turnaround_time = [0] * n # 第一个作业的开始时间和完成时间等于到达时间和执行时间 turnaround_time[0] = burst_time[0] for i in range(1, n): # 当前作业的等待时间等于前一个作业的完成时间减去到达时间 waiting_time[i] = turnaround_time[i-1] - arrival_time[i] # 当前作业的完成时间等于等待时间加上执行时间 turnaround_time[i] = waiting_time[i] + burst_time[i] # 计算平均等待时间和平均周转时间 avg_waiting_time = sum(waiting_time) / n avg_turnaround_time = sum(turnaround_time) / n print("作业\t到达时间\t执行时间\t等待时间\t完成时间") for i in range(n): print(f"Job {i+1}\t{arrival_time[i]}\t\t{burst_time[i]}\t\t{waiting_time[i]}\t\t{turnaround_time[i]}") print("平均等待时间:", avg_waiting_time) print("平均周转时间:", avg_turnaround_time) # 示例输入 arrival_time = [0, 1, 2, 4] burst_time = [3, 5, 2, 1] # 调用算法实现 fcfs(arrival_time, burst_time) ``` SJF(Shortest Job First)是一种最短作业优先的作业调度算法。该算法根据作业的执行时间选择最短的作业来分配CPU的执行时间。 下面是使用Python实现SJF作业调度算法的示例代码: ```python def sjf(arrival_time, burst_time): n = len(arrival_time) # 初始化等待时间和完成时间数组 waiting_time = [0] * n turnaround_time = [0] * n # 创建列表来存储作业的剩余执行时间 remaining_time = burst_time[:] # 统计已经完成的作业数量 completed_jobs = 0 # 当还有作业未完成时,进行调度 while completed_jobs < n: # 初始化最小执行时间和最短作业索引 min_time = float('inf') shortest_job = None # 找到还未完成的作业中最短的执行时间 for i in range(n): if arrival_time[i] <= sum(turnaround_time[: completed_jobs]): if remaining_time[i] < min_time: min_time = remaining_time[i] shortest_job = i # 更新等待时间和周转时间 waiting_time[shortest_job] = sum(turnaround_time[: completed_jobs]) - arrival_time[shortest_job] turnaround_time[shortest_job] = waiting_time[shortest_job] + burst_time[shortest_job] # 标记作业为已完成 completed_jobs += 1 remaining_time[shortest_job] = float('inf') # 计算平均等待时间和平均周转时间 avg_waiting_time = sum(waiting_time) / n avg_turnaround_time = sum(turnaround_time) / n print("作业\t到达时间\t执行时间\t等待时间\t完成时间") for i in range(n): print(f"Job {i+1}\t{arrival_time[i]}\t\t{burst_time[i]}\t\t{waiting_time[i]}\t\t{turnaround_time[i]}") print("平均等待时间:", avg_waiting_time) print("平均周转时间:", avg_turnaround_time) # 示例输入 arrival_time = [0, 1, 2, 4] burst_time = [3, 5, 2, 1] # 调用算法实现 sjf(arrival_time, burst_time) ``` 以上代码分别实现FCFSSJF两种作业调度算法,可以根据不同的作业到达时间和执行时间,运行相应的示例输入来测试算法的实现和输出结果。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值