调度算法FCFS代码python

好的，以下是FCFS调度算法的Python代码：

def fcfs(processes):
    # 按照到达时间排序
    processes.sort(key=lambda x: x[0])
    
    # 初始化等待时间和总等待时间
    wait_time = 0
    total_wait_time = 0
    
    # 遍历所有进程
    for i in range(len(processes)):
        # 计算等待时间
        wait_time = max(wait_time, processes[i][0]) - processes[i][0]
        # 累加总等待时间
        total_wait_time += wait_time
        # 更新等待时间
        wait_time += processes[i][1]
    
    # 返回平均等待时间
    return total_wait_time / len(processes)

其中，`processes` 是一个二维列表，每个子列表包含两个元素，分别是进程的到达时间和执行时间。

相关问题

用Python写进程调度算法FCFS

在Python中实现先来先服务（FCFS）调度算法的代码如下所示[^1]：

class Process:
    def __init__(self, pid, burst_time):
        self.pid = pid
        self.burst_time = burst_time

def fcfs_scheduling(processes):
    waiting_time = 0
    total_waiting_time = 0
    turnaround_time = 0
    total_turnaround_time = 0

    for process in processes:
        waiting_time += process.burst_time
        turnaround_time = waiting_time
        total_waiting_time += waiting_time
        total_turnaround_time += turnaround_time

    avg_waiting_time = total_waiting_time / len(processes)
    avg_turnaround_time = total_turnaround_time / len(processes)

    print("Average Waiting Time:", avg_waiting_time)
    print("Average Turnaround Time:", avg_turnaround_time)

# 示例用法
processes = [Process(1, 10), Process(2, 5), Process(3, 8)]
fcfs_scheduling(processes)

请注意，上述代码是一个示例，其中`Process`类表示进程，`pid`表示进程ID，`burst_time`表示进程的执行时间。`fcfs_scheduling`函数实现了先来先服务调度算法，计算了平均等待时间和平均周转时间。

fcfs调度算法python实现

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

class Process:
    def __init__(self, pid, arrival_time, burst_time):
        self.pid = pid
        self.arrival_time = arrival_time
        self.burst_time = burst_time

def fcfs(processes):
    n = len(processes)
    waiting_time = [0] * n
    turnaround_time = [0] * n

    # 计算第一个进程的等待时间
    waiting_time[0] = 0

    # 计算每个进程的等待时间和周转时间
    for i in range(1, n):
        waiting_time[i] = processes[i-1].burst_time + waiting_time[i-1]
        turnaround_time[i-1] = waiting_time[i-1] + processes[i-1].burst_time

    # 计算最后一个进程的周转时间
    turnaround_time[n-1] = waiting_time[n-1] + processes[n-1].burst_time

    # 计算平均等待时间和平均周转时间
    avg_waiting_time = sum(waiting_time) / n
    avg_turnaround_time = sum(turnaround_time) / n

    # 打印每个进程的信息
    print("Process\tArrival Time\tBurst Time\tWaiting Time\tTurnaround Time")
    for i in range(n):
        print(f"{processes[i].pid}\t\t{processes[i].arrival_time}\t\t{processes[i].burst_time}\t\t{waiting_time[i]}\t\t{turnaround_time[i]}")

    # 打印平均等待时间和平均周转时间
    print(f"\nAverage waiting time: {avg_waiting_time:.2f}")
    print(f"Average turnaround time: {avg_turnaround_time:.2f}")

# 示例用法
if __name__ == "__main__":
    processes = [
        Process("P1", 0, 5),
        Process("P2", 1, 3),
        Process("P3", 2, 8),
        Process("P4", 3, 6)
    ]
    fcfs(processes)

输出结果如下：

Process	Arrival Time	Burst Time	Waiting Time	Turnaround Time
P1		0		5		0		5
P2		1		3		5		8
P3		2		8		8		16
P4		3		6		16		22

Average waiting time: 7.25
Average turnaround time: 12.75

其中，`Process` 类表示进程，包含进程 ID、到达时间和执行时间。`fcfs` 函数接受一个进程列表作为参数，计算每个进程的等待时间和周转时间，并输出结果。在示例中，我们创建了一个包含 4 个进程的列表，并将其作为参数传递给 `fcfs` 函数。