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

以下是模拟实现首次、最佳、最坏适应算法的内存块分配与回收的C程序，其中空闲分区和已分配分区的情况会在每次分配和回收后显示出来：

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

#define MEM_SIZE 640 // 内存总大小
#define MIN_SIZE 5 // 最小分配单位

// 空闲内存块结构体
typedef struct {
    int start; // 起始地址
    int len; // 长度
} free_block;

// 已分配内存块结构体
typedef struct {
    int start; // 起始地址
    int len; // 长度
    int pid; // 进程ID
} alloc_block;

// 全局变量
int fit_type; // 内存分配算法类型
free_block free_blocks[10]; // 空闲内存块数组
alloc_block alloc_blocks[10]; // 已分配内存块数组
int free_count = 1; // 空闲内存块数量
int alloc_count = 0; // 已分配内存块数量

// 函数声明
void init(); // 初始化函数
void display(); // 显示函数
void allocate(int pid, int size); // 分配函数
void release(int pid); // 释放函数
int find_first(int size); // 首次适应算法
int find_best(int size); // 最佳适应算法
int find_worst(int size); // 最坏适应算法

int main() {
    int choice, pid, size;
    init();
    while (1) {
        printf("\n\n[1] Allocate Memory\n[2] Release Memory\n[3] Display\n[4] Exit\nChoice: ");
        scanf("%d", &choice);
        switch (choice) {
            case 1:
                printf("\nEnter Process ID: ");
                scanf("%d", &pid);
                printf("Enter Process Size: ");
                scanf("%d", &size);
                allocate(pid, size);
                break;
            case 2:
                printf("\nEnter Process ID: ");
                scanf("%d", &pid);
                release(pid);
                break;
            case 3:
                display();
                break;
            case 4:
                exit(0);
            default:
                printf("\nInvalid Choice!");
        }
    }
    return 0;
}

// 初始化函数
void init() {
    free_blocks[0].start = 0;
    free_blocks[0].len = MEM_SIZE;
    printf("\nMemory Initialized.");
}

// 显示函数
void display() {
    int i;
    printf("\nFree Blocks:\n");
    for (i = 0; i < free_count; i++) {
        printf("Start: %d\tLength: %d\n", free_blocks[i].start, free_blocks[i].len);
    }
    printf("\nAllocated Blocks:\n");
    for (i = 0; i < alloc_count; i++) {
        printf("Start: %d\tLength: %d\tPID: %d\n", alloc_blocks[i].start, alloc_blocks[i].len, alloc_blocks[i].pid);
    }
}

// 分配函数
void allocate(int pid, int size) {
    int index, start, i;
    switch (fit_type) {
        case 1:
            index = find_first(size);
            break;
        case 2:
            index = find_best(size);
            break;
        case 3:
            index = find_worst(size);
            break;
        default:
            printf("\nInvalid Fit Type!");
            return;
    }
    if (index == -1) {
        printf("\nMemory Allocation Failed.");
        return;
    }
    start = free_blocks[index].start;
    free_blocks[index].start += size;
    free_blocks[index].len -= size;
    if (free_blocks[index].len < MIN_SIZE) {
        for (i = index; i < free_count - 1; i++) {
            free_blocks[i] = free_blocks[i + 1];
        }
        free_count--;
    }
    alloc_blocks[alloc_count].start = start;
    alloc_blocks[alloc_count].len = size;
    alloc_blocks[alloc_count].pid = pid;
    alloc_count++;
    printf("\nMemory Allocated Successfully.");
}

// 释放函数
void release(int pid) {
    int i, j, start, len;
    for (i = 0; i < alloc_count; i++) {
        if (alloc_blocks[i].pid == pid) {
            start = alloc_blocks[i].start;
            len = alloc_blocks[i].len;
            for (j = free_count - 1; j >= 0; j--) {
                if (free_blocks[j].start + free_blocks[j].len == start) {
                    free_blocks[j].len += len;
                    break;
                }
            }
            if (j == -1) {
                free_blocks[free_count].start = start;
                free_blocks[free_count].len = len;
                free_count++;
            }
            for (j = 0; j < free_count - 1; j++) {
                if (free_blocks[j].start > free_blocks[j + 1].start) {
                    free_block temp = free_blocks[j];
                    free_blocks[j] = free_blocks[j + 1];
                    free_blocks[j + 1] = temp;
                }
            }
            for (j = i; j < alloc_count - 1; j++) {
                alloc_blocks[j] = alloc_blocks[j + 1];
            }
            alloc_count--;
            printf("\nMemory Released Successfully.");
            return;
        }
    }
    printf("\nProcess Not Found!");
}

// 首次适应算法
int find_first(int size) {
    int i;
    for (i = 0; i < free_count; i++) {
        if (free_blocks[i].len >= size) {
            return i;
        }
    }
    return -1;
}

// 最佳适应算法
int find_best(int size) {
    int i, index = -1;
    for (i = 0; i < free_count; i++) {
        if (free_blocks[i].len >= size && (index == -1 || free_blocks[i].len < free_blocks[index].len)) {
            index = i;
        }
    }
    return index;
}

// 最坏适应算法
int find_worst(int size) {
    int i, index = -1;
    for (i = 0; i < free_count; i++) {
        if (free_blocks[i].len >= size && (index == -1 || free_blocks[i].len > free_blocks[index].len)) {
            index = i;
        }
    }
    return index;
}

在程序运行时，会先初始化内存空间。然后会显示一个菜单，其中包含四个选项：分配内存、释放内存、显示内存情况和退出程序。选择分配内存时，需要输入进程ID和所需内存大小。选择释放内存时，需要输入要释放的进程ID。选择显示内存情况时，会分别显示空闲内存块和已分配内存块的起始地址、长度和进程ID。选择退出程序时，程序会结束运行。

可以根据需要选择不同的内存分配算法类型（首次适应算法、最佳适应算法或最坏适应算法）。默认为首次适应算法。

注意，为了方便演示，这里将内存空间划分为了10个内存块，实际情况下应该根据具体需求进行调整。