Python模拟FIFO（先进先出）、最佳置换和LRU（最近最少使用）算法

def print_frames(frames, frame_count, lost_page=False):
    """
    打印当前页框的状态。

    参数:
    - frames: 当前页框列表
    - frame_count: 页框数
    """
    output = ['-'] * frame_count
    for i in range(len(frames)):
        output[frame_count - len(frames) + i] = frames[i]
    if lost_page:
        output.append("（缺页）")
    print(" ".join(map(str, output)))

def fifo(page_sequence, frame_count):
    """
    计算FIFO页面置换算法的缺页次数，并打印每次页面引用到来后的页框情况。

    参数:
    - page_sequence: 页面引用序列
    - frame_count: 页框数

    返回:
    - 缺页次数
    """
    frames = []  # 用于存储当前页框中的页面
    page_faults = 0  # 缺页次数计数
    for page in page_sequence:
        lost_page = False
        if page not in frames:
            lost_page = True
            if len(frames) < frame_count:
                frames.append(page)  # 页框未满，直接添加页面
            else:
                frames.pop(0)  # 页框已满，移除最早进入的页面
                frames.append(page)  # 添加新页面
            page_faults += 1  # 缺页次数加1
        print_frames(frames, frame_count, lost_page)  # 打印当前页框状态
    return page_faults

def optimal(page_sequence, frame_count):
    """
    计算最佳页面置换算法的缺页次数，并打印每次页面引用到来后的页框情况。

    参数:
    - page_sequence: 页面引用序列
    - frame_count: 页框数

    返回:
    - 缺页次数
    """
    frames = []  # 用于存储当前页框中的页面
    page_faults = 0  # 缺页次数计数
    for i in range(len(page_sequence)):
        page = page_sequence[i]
        lost_page = False
        if page not in frames:
            lost_page = True
            if len(frames) < frame_count:
                frames.append(page)  # 页框未满，直接添加页面
            else:
                future_indices = [page_sequence[i:].index(f) if f in page_sequence[i:] else float('inf') for f in frames]
                # 计算每个页面在未来的访问时间，选择最远的那个页面进行置换（若未来不再访问，则将其视为无穷远）
                farthest_index = future_indices.index(max(future_indices))  # 获取最远的页面索引
                frames[farthest_index] = page  # 置换页面
            page_faults += 1  # 缺页次数加1
        print_frames(frames, frame_count, lost_page)  # 打印当前页框状态
    return page_faults

def lru(page_sequence, frame_count):
    """
    计算LRU页面置换算法的缺页次数，并打印每次页面引用到来后的页框情况。

    参数:
    - page_sequence: 页面引用序列
    - frame_count: 页框数

    返回:
    - 缺页次数
    """
    frames = []  # 用于存储当前页框中的页面
    page_faults = 0  # 缺页次数计数
    lru_stack = []  # 用于记录页面最近使用情况的栈
    for page in page_sequence:
        lost_page = False
        if page not in frames:
            lost_page = True
            if len(frames) < frame_count:
                frames.append(page)  # 页框未满，直接添加页面
            else:
                lru_page = lru_stack.pop(0)  # 获取最近最久未使用的页面
                frames[frames.index(lru_page)] = page  # 置换页面
            page_faults += 1  # 缺页次数加1
        else:
            lru_stack.remove(page)  # 如果没有缺页，则将页面从栈中移除，再添加到栈顶，表示刚刚使用
        lru_stack.append(page)  # 将页面添加到栈顶
        print_frames(frames, frame_count, lost_page)  # 打印当前页框状态
    return page_faults

if __name__ == "__main__":
    # 定义页面引用序列和页框数
    page_sequence = [1, 2, 4, 3, 5, 2, 1, 3, 4, 5, 3, 4]
    frame_count = 4

    # 计算FIFO算法的缺页次数并打印页框变化情况
    print("FIFO 页框变化情况:")
    fifo_faults = fifo(page_sequence, frame_count)
    print(f"FIFO 缺页次数: {fifo_faults}\n")

    # 计算最佳置换算法的缺页次数并打印页框变化情况
    print("最佳置换 页框变化情况:")
    optimal_faults = optimal(page_sequence, frame_count)
    print(f"最佳置换 缺页次数: {optimal_faults}\n")

    # 计算LRU算法的缺页次数并打印页框变化情况
    print("LRU 页框变化情况:")
    lru_faults = lru(page_sequence, frame_count)
    print(f"LRU 缺页次数: {lru_faults}")

FIFO 页框变化情况:
- - - 1 （缺页）
- - 1 2 （缺页）
- 1 2 4 （缺页）
1 2 4 3 （缺页）
2 4 3 5 （缺页）
2 4 3 5
4 3 5 1 （缺页）
4 3 5 1
4 3 5 1
4 3 5 1
4 3 5 1
4 3 5 1
FIFO 缺页次数: 6

最佳置换 页框变化情况:
- - - 1 （缺页）
- - 1 2 （缺页）
- 1 2 4 （缺页）
1 2 4 3 （缺页）
1 2 5 3 （缺页）
1 2 5 3
1 2 5 3
1 2 5 3
4 2 5 3 （缺页）
4 2 5 3
4 2 5 3
4 2 5 3
最佳置换 缺页次数: 6

LRU 页框变化情况:
- - - 1 （缺页）
- - 1 2 （缺页）
- 1 2 4 （缺页）
1 2 4 3 （缺页）
5 2 4 3 （缺页）
5 2 4 3
5 2 1 3 （缺页）
5 2 1 3
4 2 1 3 （缺页）
4 5 1 3 （缺页）
4 5 1 3
4 5 1 3
LRU 缺页次数: 8

Process finished with exit code 0