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

好的，以下是一个简单的最坏适应算法的内存块分配和回收的 C 语言程序：

#include <stdio.h>

#define MEM_SIZE 640 // 内存总大小
#define MIN_SIZE 4   // 最小内存块大小

// 内存块结构体
struct mem_block {
    int size;           // 内存块大小
    int is_free;        // 是否空闲
    struct mem_block* next; // 下一个内存块
};

// 内存块链表头指针
struct mem_block* mem_head = NULL;

// 初始化内存块链表
void init_mem_list() {
    mem_head = (struct mem_block*) malloc(sizeof(struct mem_block));
    mem_head->size = MEM_SIZE;
    mem_head->is_free = 1;
    mem_head->next = NULL;
}

// 分配内存块
void* my_malloc(int size) {
    struct mem_block* p = mem_head;
    struct mem_block* worst = NULL;
    int worst_size = 0;
    // 找到最坏适应的空闲内存块
    while (p != NULL) {
        if (p->is_free && p->size >= size && p->size > worst_size) {
            worst = p;
            worst_size = p->size;
        }
        p = p->next;
    }
    // 如果找到了空闲内存块，则进行分割
    if (worst != NULL) {
        if (worst_size - size >= MIN_SIZE) {
            struct mem_block* new_block = (struct mem_block*) malloc(sizeof(struct mem_block));
            new_block->size = size;
            new_block->is_free = 0;
            new_block->next = worst->next;
            worst->next = new_block;
            worst->size -= size;
        } else {
            worst->is_free = 0;
        }
        return (void*) (worst + 1);
    }
    // 找不到合适的空闲内存块，分配失败
    return NULL;
}

// 回收内存块
void my_free(void* ptr) {
    if (ptr == NULL) {
        return;
    }
    struct mem_block* p = (struct mem_block*) ptr - 1;
    p->is_free = 1;
    // 将相邻的空闲内存块合并
    while (p->next != NULL && p->next->is_free) {
        p->size += p->next->size;
        p->next = p->next->next;
    }
}

// 打印内存块列表
void print_mem_list() {
    struct mem_block* p = mem_head;
    while (p != NULL) {
        printf("%dKB [%s]\n", p->size, p->is_free ? "free" : "used");
        p = p->next;
    }
    printf("\n");
}

int main() {
    init_mem_list();
    print_mem_list();

    // 分配一些内存
    void* p1 = my_malloc(100);
    void* p2 = my_malloc(200);
    void* p3 = my_malloc(300);
    void* p4 = my_malloc(50);
    print_mem_list();

    // 回收一些内存
    my_free(p2);
    my_free(p4);
    print_mem_list();

    // 分配更多内存
    void* p5 = my_malloc(150);
    void* p6 = my_malloc(100);
    print_mem_list();

    return 0;
}

程序中，首先定义了一个内存块结构体，包含了内存块大小、是否空闲和下一个内存块的指针。然后定义了一个内存块链表头指针 mem_head，并实现了初始化内存块列表、分配内存块、回收内存块和打印内存块列表等函数。

在分配内存块时，程序采用了最坏适应算法，通过遍历内存块链表，找到最大且足够容纳分配大小的空闲内存块，如果找到了则进行分割，否则分配失败。

在回收内存块时，程序会将回收的内存块标记为空闲状态，并尝试将相邻的空闲内存块合并成一个更大的空闲内存块。

最后，程序演示了如何使用这些函数来分配和回收内存块，并打印出每次分配和回收后的空闲分区和已分配分区的情况。