可变分区的最佳、最先、最坏算法C实现

可变分区的最佳适应算法、最先适应算法和最坏适应算法的 C 语言实现如下：

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

#define MAXSIZE 1000

/* 内存分区结构体 */
typedef struct {
    int startAddr;  // 起始地址
    int size;       // 分区大小
    int status;     // 分区状态，0表示空闲，1表示已分配
} Partition;

Partition partitions[MAXSIZE];  // 存储分区的数组
int partitionCount = 0;         // 分区数量

/* 初始化分区 */
void initPartitions(int memSize) {
    partitions[0].startAddr = 0;
    partitions[0].size = memSize;
    partitions[0].status = 0;
    partitionCount = 1;
}

/* 显示分区情况 */
void showPartitions() {
    printf("起始地址\t分区大小\t分区状态\n");
    for (int i = 0; i < partitionCount; i++) {
        printf("%d\t\t%d\t\t", partitions[i].startAddr, partitions[i].size);
        if (partitions[i].status == 0) {
            printf("空闲\n");
        } else {
            printf("已分配\n");
        }
    }
}

/* 最佳适应算法 */
int bestFit(int size) {
    int bestIndex = -1;
    int minSize = MAXSIZE;
    for (int i = 0; i < partitionCount; i++) {
        if (partitions[i].status == 0 && partitions[i].size >= size && partitions[i].size < minSize) {
            bestIndex = i;
            minSize = partitions[i].size;
        }
    }
    return bestIndex;
}

/* 最先适应算法 */
int firstFit(int size) {
    for (int i = 0; i < partitionCount; i++) {
        if (partitions[i].status == 0 && partitions[i].size >= size) {
            return i;
        }
    }
    return -1;
}

/* 最坏适应算法 */
int worstFit(int size) {
    int worstIndex = -1;
    int maxSize = -1;
    for (int i = 0; i < partitionCount; i++) {
        if (partitions[i].status == 0 && partitions[i].size >= size && partitions[i].size > maxSize) {
            worstIndex = i;
            maxSize = partitions[i].size;
        }
    }
    return worstIndex;
}

/* 分配内存 */
void allocate(int index, int size) {
    Partition *p = &partitions[index];
    if (p->size == size) {  // 分区大小正好
        p->status = 1;
    } else {  // 分区大小大于需求，拆分分区
        Partition newPartition = {
            p->startAddr + size,
            p->size - size,
            0
        };
        p->size = size;
        p->status = 1;
        partitions[partitionCount++] = newPartition;
    }
}

/* 释放内存 */
void release(int index) {
    partitions[index].status = 0;
    // 合并相邻的空闲分区
    if (index > 0 && partitions[index - 1].status == 0) {
        partitions[index - 1].size += partitions[index].size;
        for (int i = index; i < partitionCount - 1; i++) {
            partitions[i] = partitions[i + 1];
        }
        partitionCount--;
        index--;
    }
    if (index < partitionCount - 1 && partitions[index + 1].status == 0) {
        partitions[index].size += partitions[index + 1].size;
        for (int i = index + 1; i < partitionCount - 1; i++) {
            partitions[i] = partitions[i + 1];
        }
        partitionCount--;
    }
}

int main() {
    int choice, size;
    initPartitions(640);
    printf("========== 可变分区内存管理 ==========\n");
    while (1) {
        printf("\n1. 显示分区情况\n2. 分配内存\n3. 释放内存\n4. 退出程序\n");
        printf("请输入操作编号：");
        scanf("%d", &choice);
        switch (choice) {
            case 1:
                showPartitions();
                break;
            case 2:
                printf("请输入分配的内存大小：");
                scanf("%d", &size);
                printf("请选择分配算法（1. 最佳适应 2. 最先适应 3. 最坏适应）：");
                scanf("%d", &choice);
                switch (choice) {
                    case 1:
                        if ((choice = bestFit(size)) == -1) {
                            printf("分配失败：没有足够的空闲内存！\n");
                        } else {
                            allocate(choice, size);
                            printf("分配成功！\n");
                        }
                        break;
                    case 2:
                        if ((choice = firstFit(size)) == -1) {
                            printf("分配失败：没有足够的空闲内存！\n");
                        } else {
                            allocate(choice, size);
                            printf("分配成功！\n");
                        }
                        break;
                    case 3:
                        if ((choice = worstFit(size)) == -1) {
                            printf("分配失败：没有足够的空闲内存！\n");
                        } else {
                            allocate(choice, size);
                            printf("分配成功！\n");
                        }
                        break;
                    default:
                        printf("无效的选择！\n");
                        break;
                }
                break;
            case 3:
                printf("请输入释放的分区编号：");
                scanf("%d", &choice);
                if (choice < 0 || choice >= partitionCount) {
                    printf("无效的编号！\n");
                } else if (partitions[choice].status == 0) {
                    printf("该分区未分配！\n");
                } else {
                    release(choice);
                    printf("释放成功！\n");
                }
                break;
            case 4:
                printf("程序已退出。\n");
                exit(0);
            default:
                printf("无效的选择！\n");
                break;
        }
    }
    return 0;
}

在这个实现中，我们使用了一个 `Partition` 结构体来表示每个分区，并使用一个 `partitions` 数组来存储所有分区。`partitionCount` 变量记录了分区的数量。这里实现了初始化分区、显示分区情况、最佳适应算法、最先适应算法、最坏适应算法、分配内存和释放内存等功能。可以根据需要进行修改和扩展。