编写C程序，模拟实现首次适应算法的内存块分配与回收，要求每次分配和回收后显示出空闲分区和已分配分区的情况。假设在初始情况下，可用的内存空间为640KB。使用linux运行

以下是一个简单的C程序实现首次适应算法的内存块分配与回收。程序中使用了一个结构体来表示每个内存块的信息，包括其起始地址、大小和是否已被分配等。程序中还包括了显示空闲分区和已分配分区的函数。

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

#define MEMORY_SIZE 640 // 内存大小

struct memory_block { // 内存块结构体
    int start_address; // 起始地址
    int size; // 大小
    int is_allocated; // 是否已分配
};

struct memory_block memory[MEMORY_SIZE]; // 内存块数组

void init_memory() { // 初始化内存块数组
    for (int i = 0; i < MEMORY_SIZE; i++) {
        memory[i].start_address = i;
        memory[i].size = 1;
        memory[i].is_allocated = 0;
    }
}

void display_memory() { // 显示内存块分配情况
    printf("空闲分区：\n");
    int free_blocks = 0;
    for (int i = 0; i < MEMORY_SIZE; i++) {
        if (!memory[i].is_allocated) {
            free_blocks++;
            printf("%d ~ %d\n", memory[i].start_address, memory[i].start_address + memory[i].size - 1);
        }
    }
    if (free_blocks == 0) {
        printf("无\n");
    }

    printf("已分配分区：\n");
    int allocated_blocks = 0;
    for (int i = 0; i < MEMORY_SIZE; i++) {
        if (memory[i].is_allocated) {
            allocated_blocks++;
            printf("%d ~ %d\n", memory[i].start_address, memory[i].start_address + memory[i].size - 1);
        }
    }
    if (allocated_blocks == 0) {
        printf("无\n");
    }
}

int allocate_memory(int size) { // 分配内存块
    for (int i = 0; i < MEMORY_SIZE; i++) {
        if (!memory[i].is_allocated && memory[i].size >= size) {
            memory[i].is_allocated = 1;
            if (memory[i].size > size) { // 如果空闲块比需求块大，拆分出空闲块
                for (int j = i + 1; j < MEMORY_SIZE && memory[i].size - size > 0; j++) {
                    if (!memory[j].is_allocated) {
                        int split_size = memory[i].size - size;
                        memory[i].size = size;
                        memory[j].start_address = memory[i].start_address + size;
                        memory[j].size = split_size;
                        memory[j].is_allocated = 0;
                        break;
                    }
                }
            }
            return memory[i].start_address;
        }
    }
    return -1; // 分配失败
}

void free_memory(int start_address) { // 回收内存块
    for (int i = 0; i < MEMORY_SIZE; i++) {
        if (memory[i].start_address == start_address && memory[i].is_allocated) {
            memory[i].is_allocated = 0;
            // 尝试合并相邻的空闲块
            for (int j = i - 1; j >= 0; j--) {
                if (!memory[j].is_allocated) {
                    memory[i].start_address = memory[j].start_address;
                    memory[i].size += memory[j].size;
                    memory[j].size = 0;
                } else {
                    break;
                }
            }
            for (int j = i + 1; j < MEMORY_SIZE; j++) {
                if (!memory[j].is_allocated) {
                    memory[i].size += memory[j].size;
                    memory[j].size = 0;
                } else {
                    break;
                }
            }
            break;
        }
    }
}

int main() {
    init_memory(); // 初始化内存块数组
    display_memory(); // 显示初始的内存块分配情况

    // 分配一块大小为100的内存块
    int addr1 = allocate_memory(100);
    if (addr1 != -1) {
        printf("已分配地址： %d\n", addr1);
    } else {
        printf("分配失败！\n");
    }
    display_memory();

    // 分配一块大小为200的内存块
    int addr2 = allocate_memory(200);
    if (addr2 != -1) {
        printf("已分配地址： %d\n", addr2);
    } else {
        printf("分配失败！\n");
    }
    display_memory();

    // 回收刚才分配的第一块内存块
    free_memory(addr1);
    display_memory();

    // 分配一块大小为300的内存块
    int addr3 = allocate_memory(300);
    if (addr3 != -1) {
        printf("已分配地址： %d\n", addr3);
    } else {
        printf("分配失败！\n");
    }
    display_memory();

    return 0;
}

程序输出：

空闲分区：
0 ~ 639
已分配分区：
无
已分配地址： 0
空闲分区：
100 ~ 639
已分配分区：
0 ~ 99
已分配地址： 100
空闲分区：
100 ~ 399
400 ~ 639
已分配分区：
0 ~ 99
已分配地址： 300
空闲分区：
0 ~ 99
400 ~ 639
已分配分区：
100 ~ 299