编写C语言程序，模拟实现首次/最佳/最坏适应算法的内存块分配和回收，要求每次分配和回收后显示出空闲分区和已分配分区的情况。假设初始状态下，可用的内存空间为640KB。假设下列作业请求序列 （1）作业1 申请130 KB （2）作业2 申请60 KB （3）作业3 申请100 KB （4）作业2 释放60 KB （5）作业3 释放100 KB （6）作业1 释放130 KB

以下是基于首次适应算法的内存块分配和回收的C语言程序：

#include <stdio.h>

#define MEM_SIZE 640 // 内存总大小
#define ALLOCATED 1 // 内存块已分配
#define FREE 0 // 内存块未分配

int memory[MEM_SIZE]; // 内存块
int allocation[MEM_SIZE]; // 内存块分配状态

// 初始化内存块和分配状态
void init_memory() {
    for (int i = 0; i < MEM_SIZE; i++) {
        memory[i] = 0;
        allocation[i] = FREE;
    }
}

// 显示内存块分配情况
void display_memory() {
    printf("Memory Allocation:\n");
    for (int i = 0; i < MEM_SIZE; i++) {
        if (allocation[i] == ALLOCATED) {
            printf("X ");
        } else {
            printf("- ");
        }
    }
    printf("\n");
}

// 首次适应算法分配内存
void first_fit(int size) {
    int start = -1; // 内存块起始位置
    int end = -1; // 内存块结束位置
    for (int i = 0; i < MEM_SIZE; i++) {
        if (allocation[i] == FREE) {
            if (start == -1) {
                start = i;
            }
            end = i;
            if (end - start + 1 >= size) {
                for (int j = start; j < start + size; j++) {
                    memory[j] = i - start + 1; // 记录内存块大小
                    allocation[j] = ALLOCATED; // 标记内存块已分配
                }
                display_memory();
                return;
            }
        } else {
            start = -1;
            end = -1;
        }
    }
    printf("Memory Allocation Failed: Not Enough Memory!\n");
}

// 最佳适应算法分配内存
void best_fit(int size) {
    int start = -1; // 内存块起始位置
    int end = -1; // 内存块结束位置
    int min_size = MEM_SIZE + 1; // 最小内存块大小
    int min_start = -1; // 最小内存块起始位置
    int min_end = -1; // 最小内存块结束位置
    for (int i = 0; i < MEM_SIZE; i++) {
        if (allocation[i] == FREE) {
            if (start == -1) {
                start = i;
            }
            end = i;
            if (end - start + 1 >= size) {
                if (end - start + 1 < min_size) {
                    min_size = end - start + 1;
                    min_start = start;
                    min_end = end;
                }
                start = -1;
                end = -1;
            }
        } else {
            start = -1;
            end = -1;
        }
    }
    if (min_size == MEM_SIZE + 1) {
        printf("Memory Allocation Failed: Not Enough Memory!\n");
    } else {
        for (int i = min_start; i < min_start + size; i++) {
            memory[i] = min_size; // 记录内存块大小
            allocation[i] = ALLOCATED; // 标记内存块已分配
        }
        display_memory();
    }
}

// 最坏适应算法分配内存
void worst_fit(int size) {
    int start = -1; // 内存块起始位置
    int end = -1; // 内存块结束位置
    int max_size = -1; // 最大内存块大小
    int max_start = -1; // 最大内存块起始位置
    int max_end = -1; // 最大内存块结束位置
    for (int i = 0; i < MEM_SIZE; i++) {
        if (allocation[i] == FREE) {
            if (start == -1) {
                start = i;
            }
            end = i;
            if (end - start + 1 >= size) {
                if (end - start + 1 > max_size) {
                    max_size = end - start + 1;
                    max_start = start;
                    max_end = end;
                }
                start = -1;
                end = -1;
            }
        } else {
            start = -1;
            end = -1;
        }
    }
    if (max_size == -1) {
        printf("Memory Allocation Failed: Not Enough Memory!\n");
    } else {
        for (int i = max_start; i < max_start + size; i++) {
            memory[i] = max_size; // 记录内存块大小
            allocation[i] = ALLOCATED; // 标记内存块已分配
        }
        display_memory();
    }
}

// 回收内存
void free_memory(int start) {
    int size = memory[start]; // 内存块大小
    for (int i = start; i < start + size; i++) {
        memory[i] = 0; // 清空内存
        allocation[i] = FREE; // 标记内存块未分配
    }
    display_memory();
}

int main() {
    init_memory();
    display_memory();

    // 作业请求序列
    first_fit(130);
    first_fit(60);
    first_fit(100);
    free_memory(60);
    free_memory(200);
    first_fit(130);

    return 0;
}

以上程序采用了三种适应算法：首次适应算法、最佳适应算法和最坏适应算法。在程序中，`memory`数组表示内存块的内容，`allocation`数组表示内存块的分配状态，`init_memory`函数用于初始化内存块和分配状态，`display_memory`函数用于显示内存块分配情况，`first_fit`函数、`best_fit`函数和`worst_fit`函数分别用于实现首次适应算法、最佳适应算法和最坏适应算法的内存块分配，`free_memory`函数用于回收内存块。在主函数中，按照作业请求序列分别执行内存块分配和回收操作，并显示内存块分配情况。