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

这是一个简单的最坏适应算法的内存分配与回收的C程序实现。在程序中，我们使用了链表来管理内存分区，每个节点表示一个内存块，包含了该内存块的大小和起始地址信息。程序中提供了两个函数，一个用于分配内存，另一个用于释放内存。在每次分配或释放内存后，程序会显示当前的空闲分区和已分配分区的情况。

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

#define MAX_MEM 640   // 最大内存空间

struct mem_block {
    int size;         // 内存块大小
    int start_addr;   // 内存块起始地址
    struct mem_block *next;   // 下一个内存块
};

struct mem_block *free_list;   // 空闲分区链表头指针
struct mem_block *used_list;   // 已分配分区链表头指针

// 初始化内存分区
void init_mem() {
    free_list = (struct mem_block*)malloc(sizeof(struct mem_block));
    free_list->size = MAX_MEM;
    free_list->start_addr = 0;
    free_list->next = NULL;
    used_list = NULL;
}

// 显示内存分区情况
void show_mem() {
    struct mem_block *p = free_list;
    printf("Free blocks:\n");
    while (p) {
        printf("start addr: %d, size: %d\n", p->start_addr, p->size);
        p = p->next;
    }
    printf("\nUsed blocks:\n");
    p = used_list;
    while (p) {
        printf("start addr: %d, size: %d\n", p->start_addr, p->size);
        p = p->next;
    }
    printf("\n");
}

// 最坏适应算法分配内存
void *worst_fit_alloc(int size) {
    struct mem_block *p = free_list;
    struct mem_block *prev = NULL;
    struct mem_block *max_block = NULL;
    struct mem_block *max_prev = NULL;
    int max_size = 0;
    // 找到最大的空闲块
    while (p) {
        if (p->size >= size && p->size > max_size) {
            max_size = p->size;
            max_block = p;
            max_prev = prev;
        }
        prev = p;
        p = p->next;
    }
    if (!max_block) {
        printf("Error: no enough memory!\n");
        return NULL;
    }
    // 如果空闲块的大小正好等于请求的大小，直接将该块分配出去
    if (max_size == size) {
        if (max_prev) {
            max_prev->next = max_block->next;
        } else {
            free_list = max_block->next;
        }
    } else {
        // 否则，将空闲块分割成两部分，一部分分配出去，另一部分放回空闲分区链表中
        struct mem_block *new_block = (struct mem_block*)malloc(sizeof(struct mem_block));
        new_block->size = size;
        new_block->start_addr = max_block->start_addr;
        new_block->next = NULL;
        max_block->size -= size;
        max_block->start_addr += size;
        if (max_prev) {
            max_prev->next = max_block->next;
        } else {
            free_list = max_block->next;
        }
        // 将新分配的块加入已分配分区链表中
        if (!used_list) {
            used_list = new_block;
        } else {
            new_block->next = used_list;
            used_list = new_block;
        }
    }
    return (void*)used_list->start_addr;
}

// 释放内存
void free_mem(void *addr) {
    struct mem_block *p = used_list;
    struct mem_block *prev = NULL;
    // 找到要释放的块
    while (p) {
        if (p->start_addr == (int)addr) {
            break;
        }
        prev = p;
        p = p->next;
    }
    if (!p) {
        printf("Error: invalid address!\n");
        return;
    }
    // 将要释放的块从已分配分区链表中删除
    if (prev) {
        prev->next = p->next;
    } else {
        used_list = p->next;
    }
    // 将要释放的块加入空闲分区链表中
    struct mem_block *new_block = (struct mem_block*)malloc(sizeof(struct mem_block));
    new_block->size = p->size;
    new_block->start_addr = p->start_addr;
    new_block->next = NULL;
    struct mem_block *q = free_list;
    struct mem_block *q_prev = NULL;
    // 找到要插入的位置
    while (q && q->start_addr < new_block->start_addr) {
        q_prev = q;
        q = q->next;
    }
    // 插入到链表中
    if (q_prev) {
        q_prev->next = new_block;
    } else {
        free_list = new_block;
    }
    new_block->next = q;
}

int main() {
    init_mem();   // 初始化内存分区
    show_mem();   // 显示初始内存分区情况
    void *addr1 = worst_fit_alloc(100);   // 分配100KB内存
    show_mem();   // 显示分配后的内存分区情况
    void *addr2 = worst_fit_alloc(200);   // 分配200KB内存
    show_mem();   // 显示分配后的内存分区情况
    void *addr3 = worst_fit_alloc(400);   // 分配400KB内存
    show_mem();   // 显示分配后的内存分区情况
    free_mem(addr2);   // 释放200KB内存
    show_mem();   // 显示释放后的内存分区情况
    void *addr4 = worst_fit_alloc(300);   // 分配300KB内存
    show_mem();   // 显示分配后的内存分区情况
    return 0;
}

在linux系统中编译并运行该程序，可以使用以下命令：

gcc worst_fit_alloc.c -o worst_fit_alloc
./worst_fit_alloc