设计一个请求页式存储管理方案，编写模拟程序实现具体过程，并计算缺页率(所有内存开始都是空的，凡第一次用到的页面都产生一次缺页中断)。 要求实现下列页面置换算法: （1）先进先出算法(FIFO) : 淘汰最先进入内存的页面，即选择在内存中驻留时间最久的页面予以淘汰。 （2）最近最久未使用算法(LRU) : 淘汰最近最久未被使用的页面。 程序中用户可选择置换算法，先输入所有页面号，为系统分配物理块，依次按照FIFO或LRU算法进行置换。 使用C语言，换页过程以数列形式输出显示，物理块数由用户输入决定

以下是一个简单的请求页式存储管理方案的模拟程序，包含了FIFO和LRU两种页面置换算法。程序中以数组模拟物理块，以链表模拟页面请求序列。用户可以输入页面请求序列和物理块数，选择置换算法，程序会输出所有的页面请求和置换过程，并计算缺页率。

#include <stdio.h>
#include <stdlib.h>

typedef struct page {
    int id; // 页面编号
    int time; // 进入内存的时间
    struct page *next; // 链表指针
} Page;

int main() {
    int n; // 物理块数
    int method; // 置换算法
    printf("请输入物理块数：");
    scanf("%d", &n);
    printf("请选择置换算法：\n");
    printf("1. 先进先出算法(FIFO)\n");
    printf("2. 最近最久未使用算法(LRU)\n");
    printf("请输入算法编号：");
    scanf("%d", &method);

    int *block = (int*)malloc(sizeof(int) * n); // 物理块数组
    int head = 0; // 队列头指针
    int tail = 0; // 队列尾指针
    int count = 0; // 缺页中断次数

    Page *headPage = NULL; // 页面请求链表头指针
    Page *tailPage = NULL; // 页面请求链表尾指针

    printf("请输入页面请求序列，以-1结束：");
    int id;
    while (1) {
        scanf("%d", &id);
        if (id == -1) break;

        Page *page = (Page*)malloc(sizeof(Page)); // 创建新页面
        page->id = id;
        page->time = 0;
        page->next = NULL;

        if (headPage == NULL) { // 链表为空
            headPage = page;
            tailPage = page;
        } else { // 链表不为空
            tailPage->next = page;
            tailPage = page;
        }
    }

    Page *p = headPage;
    while (p != NULL) { // 遍历页面请求链表
        int id = p->id;
        p = p->next;

        // 查找页面是否已在物理块中
        int found = 0;
        for (int i = 0; i < count; i++) {
            if (block[i] == id) {
                found = 1;
                break;
            }
        }

        if (!found) { // 页面不在物理块中，产生缺页中断
            count++;

            if (count > n) { // 物理块已满，需要进行页面置换
                int victim;
                if (method == 1) { // FIFO算法
                    victim = block[head];
                    head = (head + 1) % n;
                } else { // LRU算法
                    int minTime = p->time;
                    victim = block[0];
                    for (int i = 0; i < n; i++) {
                        if (p->time - block[i+n] < minTime) {
                            minTime = p->time - block[i+n];
                            victim = block[i];
                        }
                    }
                }

                // 输出页面置换过程
                printf("缺页中断：%d\t", id);
                printf("页面置换：%d->%d\t", victim, id);
                for (int i = 0; i < n; i++) {
                    if (block[i] == victim) {
                        block[i] = id;
                        block[i+n] = p->time;
                        break;
                    }
                }
            } else { // 物理块未满，直接将页面调入物理块
                block[tail] = id;
                block[tail+n] = p->time;
                tail = (tail + 1) % n;

                // 输出页面调入过程
                printf("缺页中断：%d\t", id);
                for (int i = 0; i < count; i++) {
                    printf("%d ", block[i]);
                }
            }
        }

        // 更新页面进入时间
        for (int i = 0; i < n; i++) {
            if (block[i] == id) {
                block[i+n] = p->time;
                break;
            }
        }
        p->time++;
    }

    // 输出缺页率
    printf("\n缺页次数：%d\t缺页率：%.2f%%\n", count, (float)count / (float)(tailPage - headPage + 1) * 100);

    // 释放内存
    free(block);
    while (headPage != NULL) {
        Page *p = headPage;
        headPage = headPage->next;
        free(p);
    }

    return 0;
}

程序中使用了一个`Page`结构体表示页面，其中`id`表示页面编号，`time`表示页面进入内存的时间，`next`表示链表指针。在用户输入页面请求序列时，程序会创建一个新的`Page`结构体，并将其加入页面请求链表中。在遍历页面请求链表时，程序会查找当前的页面是否已经在物理块中，如果不在则产生缺页中断。

对于FIFO算法，程序会将队列头指针指向的页面置换出去，并将新的页面调入队列尾部。对于LRU算法，程序会查找物理块中最久未使用的页面，并将其置换出去。

在页面置换过程中，程序会输出每次缺页中断和页面置换的情况。最后程序会输出缺页率，并释放申请的内存。

注意，该程序中使用链表来表示页面请求序列，因为链表可以动态增长，可以方便地处理不定长的页面请求序列。但在实际操作系统中，页面请求序列一般是由作业控制块或进程控制块维护的，因此可能需要使用其他数据结构来表示。