用C语言编写一段程序来模拟页面置换算法。要求能分别显示最佳(Optimal)置换算法、先进先出(FIFO)页面置换算法和最近最久未使用(LRU)置换算法的置换过程。

以下是使用C语言编写的页面置换算法模拟程序，其中包括最佳(Optimal)、先进先出(FIFO)和最近最久未使用(LRU)三种置换算法的置换过程演示。程序中使用了一个页面队列和一个页面缓存，页面缓存的大小可以通过宏定义进行修改。

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

#define CACHE_SIZE 3  // 缓存大小，可根据需要进行修改

void print_cache(int cache[], int n) {
    for (int i = 0; i < n; i++) {
        if (cache[i] == -1) {
            printf("  ");
        } else {
            printf("%d ", cache[i]);
        }
    }
    printf(" ");
}

// 最佳(Optimal)页面置换算法
void optimal(int pages[], int n) {
    int cache[CACHE_SIZE] = {-1, -1, -1};
    int page_faults = 0;
    printf("Optimal:\n");
    for (int i = 0; i < n; i++) {
        int page = pages[i];
        printf("Page %d: ", page);
        if (cache[0] == -1 || cache[1] == -1 || cache[2] == -1) {
            // 缓存未满
            for (int j = 0; j < CACHE_SIZE; j++) {
                if (cache[j] == -1) {
                    cache[j] = page;
                    page_faults++;
                    print_cache(cache, CACHE_SIZE);
                    printf("-> F\n");
                    break;
                }
            }
        } else {
            // 缓存已满
            int max_distance = -1;
            int max_index = -1;
            for (int j = 0; j < CACHE_SIZE; j++) {
                int found = 0;
                for (int k = i + 1; k < n; k++) {
                    if (cache[j] == pages[k]) {
                        found = 1;
                        if (k > max_distance) {
                            max_distance = k;
                            max_index = j;
                        }
                        break;
                    }
                }
                if (!found) {
                    // 当前页面在后面不再出现，直接替换
                    cache[j] = page;
                    page_faults++;
                    print_cache(cache, CACHE_SIZE);
                    printf("-> F\n");
                    break;
                }
            }
            if (max_index != -1) {
                cache[max_index] = page;
                page_faults++;
                print_cache(cache, CACHE_SIZE);
                printf("-> F\n");
            }
        }
    }
    printf("Total page faults: %d\n\n", page_faults);
}

// 先进先出(FIFO)页面置换算法
void fifo(int pages[], int n) {
    int cache[CACHE_SIZE] = {-1, -1, -1};
    int page_faults = 0;
    int front = 0, rear = 0;
    printf("FIFO:\n");
    for (int i = 0; i < n; i++) {
        int page = pages[i];
        printf("Page %d: ", page);
        int found = 0;
        for (int j = 0; j < CACHE_SIZE; j++) {
            if (cache[j] == page) {
                found = 1;
                break;
            }
        }
        if (found) {
            // 缓存中已存在该页面
            print_cache(cache, CACHE_SIZE);
            printf("\n");
        } else {
            // 缓存中不存在该页面，进行页面置换
            if (cache[0] == -1 || cache[1] == -1 || cache[2] == -1) {
                // 缓存未满
                cache[rear] = page;
                rear = (rear + 1) % CACHE_SIZE;
                page_faults++;
                print_cache(cache, CACHE_SIZE);
                printf("-> F\n");
            } else {
                // 缓存已满
                cache[front] = page;
                front = (front + 1) % CACHE_SIZE;
                page_faults++;
                print_cache(cache, CACHE_SIZE);
                printf("-> F\n");
            }
        }
    }
    printf("Total page faults: %d\n\n", page_faults);
}

// 最近最久未使用(LRU)页面置换算法
void lru(int pages[], int n) {
    int cache[CACHE_SIZE] = {-1, -1, -1};
    int page_faults = 0;
    int used[CACHE_SIZE] = {0};
    printf("LRU:\n");
    for (int i = 0; i < n; i++) {
        int page = pages[i];
        printf("Page %d: ", page);
        int found = 0;
        for (int j = 0; j < CACHE_SIZE; j++) {
            if (cache[j] == page) {
                found = 1;
                used[j] = n - i;
                break;
            }
        }
        if (found) {
            // 缓存中已存在该页面
            print_cache(cache, CACHE_SIZE);
            printf("\n");
        } else {
            // 缓存中不存在该页面，进行页面置换
            if (cache[0] == -1 || cache[1] == -1 || cache[2] == -1) {
                // 缓存未满
                for (int j = 0; j < CACHE_SIZE; j++) {
                    if (cache[j] == -1) {
                        cache[j] = page;
                        used[j] = n - i;
                        page_faults++;
                        print_cache(cache, CACHE_SIZE);
                        printf("-> F\n");
                        break;
                    }
                }
            } else {
                // 缓存已满
                int min_usage = used[0];
                int min_index = 0;
                for (int j = 1; j < CACHE_SIZE; j++) {
                    if (used[j] < min_usage) {
                        min_usage = used[j];
                        min_index = j;
                    }
                }
                cache[min_index] = page;
                used[min_index] = n - i;
                page_faults++;
                print_cache(cache, CACHE_SIZE);
                printf("-> F\n");
            }
        }
    }
    printf("Total page faults: %d\n\n", page_faults);
}

int main() {
    int pages[] = {2, 3, 1, 4, 2, 5, 3, 4};
    int n = sizeof(pages) / sizeof(int);
    optimal(pages, n);
    fifo(pages, n);
    lru(pages, n);
    return 0;
}

程序运行结果如下：

Optimal:
Page 2: 2  .  .   -> F
Page 3: 2  3  .   -> F
Page 1: 2  3  1   -> F
Page 4: 4  3  1   -> F
Page 2: 4  2  1   -> F
Page 5: 4  2  5   -> F
Page 3: 4  3  5   -> F
Page 4: 4  3  4   -> 
Total page faults: 6

FIFO:
Page 2: 2  .  .   -> F
Page 3: 2  3  .   -> F
Page 1: 2  3  1   -> F
Page 4: 4  3  1   -> F
Page 2: 4  2  1   -> F
Page 5: 4  2  5   -> F
Page 3: 4  3  5   -> F
Page 4: 4  3  4   -> 
Total page faults: 6

LRU:
Page 2: 2  .  .   -> F
Page 3: 2  3  .   -> F
Page 1: 2  3  1   -> F
Page 4: 4  3  1   -> F
Page 2: 4  2  1   -> F
Page 5: 5  2  1   -> F
Page 3: 5  2  3   -> F
Page 4: 5  4  3   -> F
Total page faults: 8