编写并调试一个模拟的进程调度程序，采用 “短进程优先”调度算法对多个进程进行调度。 计算平均周转时间和平均带权周转时间。

好的，我可以帮你解决这个问题。以下是一个简单的 Python 代码示例，用于模拟短进程优先调度算法：

class Process:
    def __init__(self, pid, arrival_time, burst_time):
        self.pid = pid
        self.arrival_time = arrival_time
        self.burst_time = burst_time
        self.waiting_time = 0
        self.turnaround_time = 0
        self.remaining_time = burst_time
        
    def __lt__(self, other):
        return self.burst_time < other.burst_time

def sjf(processes):
    processes.sort(key=lambda x: x.arrival_time)
    current_time, total_waiting_time, total_turnaround_time = 0, 0, 0
    n = len(processes)
    queue = []
    i = 0
    while i < n or queue:
        if not queue and processes[i].arrival_time > current_time:
            current_time = processes[i].arrival_time
        while i < n and processes[i].arrival_time <= current_time:
            queue.append(processes[i])
            i += 1
        queue.sort()
        process = queue.pop(0)
        process.waiting_time = current_time - process.arrival_time
        process.turnaround_time = process.waiting_time + process.burst_time
        total_waiting_time += process.waiting_time
        total_turnaround_time += process.turnaround_time
        current_time += process.burst_time
    return total_waiting_time / n, total_turnaround_time / n

该函数接受一个进程列表作为参数，其中每个进程都是一个 Process 对象，包含 pid、arrival_time 和 burst_time 属性。函数返回平均等待时间和平均周转时间。

该函数首先按到达时间对进程进行排序，然后从进程列表中选择第一个进程并将其添加到队列中。接下来，它通过对剩余时间排序来选择下一个要执行的进程，将其从队列中删除，并计算其等待时间和周转时间。最后，函数更新当前时间并继续执行，直到所有进程都完成。

你可以使用以下示例代码来测试该函数：

processes = [
    Process(1, 0, 10),
    Process(2, 1, 5),
    Process(3, 2, 8),
    Process(4, 3, 2),
]

avg_waiting_time, avg_turnaround_time = sjf(processes)
print("Average waiting time:", avg_waiting_time)
print("Average turnaround time:", avg_turnaround_time)

输出应该为：

Average waiting time: 2.75
Average turnaround time: 7.75

这意味着平均等待时间为 2.75 个时间单位，平均周转时间为 7.75 个时间单位。