请使用python实现FCFS和SJF作业调度算法

### 回答1：

您可以使用Python中的collections模块来实现FCFS和SJF作业调度算法。此模块提供了一个名为deque的数据结构，可以用来模拟堆栈，队列和双端队列。您可以使用这个数据结构来实现FCFS和SJF作业调度算法。

### 回答2：
FCFS(First-Come, First-Served)是一种先到先服务的作业调度算法。该算法根据作业到达的顺序分配CPU的执行时间。

下面是使用Python实现FCFS作业调度算法的示例代码：

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作业调度算法的示例代码：

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)

以上代码分别实现了FCFS和SJF两种作业调度算法，可以根据不同的作业到达时间和执行时间，运行相应的示例输入来测试算法的实现和输出结果。