利用可变分区存储管理中最先适应分配算法、最优适应分配算法、最坏适应分配算法以及空间回收算法的工作原理，采用C语言编程，模拟实现算法功能。

以下是可变分区存储管理中最先适应分配算法、最优适应分配算法、最坏适应分配算法以及空间回收算法的C语言实现：

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

#define MAX_MEM_SIZE 1024  // 内存总大小
#define MIN_MEM_SIZE 4     // 每个分区最小大小
#define FREE 0             // 分区空闲
#define OCCUPIED 1         // 分区占用
#define INVALID -1         // 无效分区

// 分区结构体
struct partition {
    int start;    // 分区起始地址
    int end;      // 分区结束地址
    int size;     // 分区大小
    int state;    // 分区状态（FREE/OCCUPIED）
    int process;  // 所属进程ID（占用状态时有效）
};

// 分区表
struct partition partitions[MAX_MEM_SIZE / MIN_MEM_SIZE];

// 分配算法
enum {
    FIRST_FIT,
    BEST_FIT,
    WORST_FIT
};

// 初始化分区表
void init_partitions() {
    int i;
    for (i = 0; i < MAX_MEM_SIZE / MIN_MEM_SIZE; i++) {
        partitions[i].start = i * MIN_MEM_SIZE;
        partitions[i].end = (i + 1) * MIN_MEM_SIZE - 1;
        partitions[i].size = MIN_MEM_SIZE;
        partitions[i].state = FREE;
        partitions[i].process = INVALID;
    }
}

// 显示分区表
void show_partitions() {
    int i;
    printf("Partition Table:\n");
    printf("Start\tEnd\tSize\tState\tProcess\n");
    for (i = 0; i < MAX_MEM_SIZE / MIN_MEM_SIZE; i++) {
        printf("%d\t%d\t%d\t", partitions[i].start, partitions[i].end, partitions[i].size);
        if (partitions[i].state == FREE) {
            printf("Free\t-\n");
        } else {
            printf("Occupied\t%d\n", partitions[i].process);
        }
    }
}

// 最先适应分配算法
int first_fit(int size, int process) {
    int i;
    for (i = 0; i < MAX_MEM_SIZE / MIN_MEM_SIZE; i++) {
        if (partitions[i].state == FREE && partitions[i].size >= size) {
            // 分配空闲分区
            partitions[i].state = OCCUPIED;
            partitions[i].process = process;
            if (partitions[i].size > size) {
                // 分裂分区
                int j;
                for (j = MAX_MEM_SIZE / MIN_MEM_SIZE - 1; j > i; j--) {
                    partitions[j] = partitions[j - 1];
                }
                partitions[i + 1].start = partitions[i].start + size;
                partitions[i + 1].end = partitions[i].end;
                partitions[i + 1].size = partitions[i].size - size;
                partitions[i + 1].state = FREE;
                partitions[i + 1].process = INVALID;
                partitions[i].end = partitions[i].start + size - 1;
                partitions[i].size = size;
            }
            return partitions[i].start;
        }
    }
    return INVALID;
}

// 最优适应分配算法
int best_fit(int size, int process) {
    int i, best = INVALID;
    for (i = 0; i < MAX_MEM_SIZE / MIN_MEM_SIZE; i++) {
        if (partitions[i].state == FREE && partitions[i].size >= size) {
            if (best == INVALID || partitions[i].size < partitions[best].size) {
                best = i;
            }
        }
    }
    if (best != INVALID) {
        // 分配空闲分区
        partitions[best].state = OCCUPIED;
        partitions[best].process = process;
        if (partitions[best].size > size) {
            // 分裂分区
            int j;
            for (j = MAX_MEM_SIZE / MIN_MEM_SIZE - 1; j > best; j--) {
                partitions[j] = partitions[j - 1];
            }
            partitions[best + 1].start = partitions[best].start + size;
            partitions[best + 1].end = partitions[best].end;
            partitions[best + 1].size = partitions[best].size - size;
            partitions[best + 1].state = FREE;
            partitions[best + 1].process = INVALID;
            partitions[best].end = partitions[best].start + size - 1;
            partitions[best].size = size;
        }
        return partitions[best].start;
    }
    return INVALID;
}

// 最坏适应分配算法
int worst_fit(int size, int process) {
    int i, worst = INVALID;
    for (i = 0; i < MAX_MEM_SIZE / MIN_MEM_SIZE; i++) {
        if (partitions[i].state == FREE && partitions[i].size >= size) {
            if (worst == INVALID || partitions[i].size > partitions[worst].size) {
                worst = i;
            }
        }
    }
    if (worst != INVALID) {
        // 分配空闲分区
        partitions[worst].state = OCCUPIED;
        partitions[worst].process = process;
        if (partitions[worst].size > size) {
            // 分裂分区
            int j;
            for (j = MAX_MEM_SIZE / MIN_MEM_SIZE - 1; j > worst; j--) {
                partitions[j] = partitions[j - 1];
            }
            partitions[worst + 1].start = partitions[worst].start + size;
            partitions[worst + 1].end = partitions[worst].end;
            partitions[worst + 1].size = partitions[worst].size - size;
            partitions[worst + 1].state = FREE;
            partitions[worst + 1].process = INVALID;
            partitions[worst].end = partitions[worst].start + size - 1;
            partitions[worst].size = size;
        }
        return partitions[worst].start;
    }
    return INVALID;
}

// 空间回收算法
void free_partition(int start) {
    int i;
    for (i = 0; i < MAX_MEM_SIZE / MIN_MEM_SIZE; i++) {
        if (partitions[i].start == start) {
            // 释放分区
            partitions[i].state = FREE;
            partitions[i].process = INVALID;
            // 合并相邻空闲分区
            if (i > 0 && partitions[i - 1].state == FREE) {
                partitions[i - 1].end = partitions[i].end;
                partitions[i - 1].size += partitions[i].size;
                int j;
                for (j = i; j < MAX_MEM_SIZE / MIN_MEM_SIZE - 1; j++) {
                    partitions[j] = partitions[j + 1];
                }
            }
            if (i < MAX_MEM_SIZE / MIN_MEM_SIZE - 1 && partitions[i + 1].state == FREE) {
                partitions[i].end = partitions[i + 1].end;
                partitions[i].size += partitions[i + 1].size;
                int j;
                for (j = i + 1; j < MAX_MEM_SIZE / MIN_MEM_SIZE - 1; j++) {
                    partitions[j] = partitions[j + 1];
                }
            }
            break;
        }
    }
}

int main() {
    init_partitions();
    show_partitions();
    int type, size, process, addr;
    while (1) {
        printf("1. First Fit\n");
        printf("2. Best Fit\n");
        printf("3. Worst Fit\n");
        printf("4. Free Partition\n");
        printf("5. Exit\n");
        printf("Enter your choice: ");
        scanf("%d", &type);
        if (type == 5) {
            break;
        }
        switch (type) {
            case 1:
                printf("Enter process ID: ");
                scanf("%d", &process);
                printf("Enter memory size: ");
                scanf("%d", &size);
                addr = first_fit(size, process);
                if (addr == INVALID) {
                    printf("Failed to allocate memory.\n");
                } else {
                    printf("Memory allocated at address %d.\n", addr);
                    show_partitions();
                }
                break;
            case 2:
                printf("Enter process ID: ");
                scanf("%d", &process);
                printf("Enter memory size: ");
                scanf("%d", &size);
                addr = best_fit(size, process);
                if (addr == INVALID) {
                    printf("Failed to allocate memory.\n");
                } else {
                    printf("Memory allocated at address %d.\n", addr);
                    show_partitions();
                }
                break;
            case 3:
                printf("Enter process ID: ");
                scanf("%d", &process);
                printf("Enter memory size: ");
                scanf("%d", &size);
                addr = worst_fit(size, process);
                if (addr == INVALID) {
                    printf("Failed to allocate memory.\n");
                } else {
                    printf("Memory allocated at address %d.\n", addr);
                    show_partitions();
                }
                break;
            case 4:
                printf("Enter memory address: ");
                scanf("%d", &addr);
                free_partition(addr);
                printf("Memory freed.\n");
                show_partitions();
                break;
            default:
                printf("Invalid choice.\n");
                break;
        }
    }
    return 0;
}

该程序实现了最先适应分配算法、最优适应分配算法、最坏适应分配算法以及空间回收算法，并可通过菜单进行选择。在每次分配或释放内存后，程序会显示分区表的状态。