可变分区分配算法-最佳c代码

可变分区分配算法是一种动态内存分配方法，它根据进程的实际需求来分配内存块。最佳适应算法（Best Fit）是一种常见的可变分区分配算法，它试图找到最接近进程需求的内存块，以减少内存浪费。

下面是一个实现最佳适应算法的C代码示例：

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

// 定义内存块结构
typedef struct MemoryBlock {
    int start;
    int size;
    int isFree;
} MemoryBlock;

// 初始化内存块
void initializeMemory(MemoryBlock memory[], int totalSize) {
    memory[0].start = 0;
    memory[0].size = totalSize;
    memory[0].isFree = 1;
}

// 分配内存块
int allocateMemory(MemoryBlock memory[], int totalSize, int processSize) {
    int bestIndex = -1;
    int minDiff = totalSize;

    for (int i = 0; i < totalSize; i++) {
        if (memory[i].isFree && memory[i].size >= processSize) {
            int diff = memory[i].size - processSize;
            if (diff < minDiff) {
                minDiff = diff;
                bestIndex = i;
            }
        }
    }

    if (bestIndex != -1) {
        // 分割内存块
        if (memory[bestIndex].size - processSize > 0) {
            for (int i = totalSize - 1; i > bestIndex; i--) {
                memory[i + 1] = memory[i];
            }
            memory[bestIndex + 1].start = memory[bestIndex].start + processSize;
            memory[bestIndex + 1].size = memory[bestIndex].size - processSize;
            memory[bestIndex + 1].isFree = 1;
            memory[bestIndex].size = processSize;
        }
        memory[bestIndex].isFree = 0;
        return memory[bestIndex].start;
    }

    return -1; // 分配失败
}

// 释放内存块
void freeMemory(MemoryBlock memory[], int start) {
    for (int i = 0; i < 100; i++) {
        if (memory[i].start == start) {
            memory[i].isFree = 1;
            // 合并空闲块
            if (i > 0 && memory[i - 1].isFree) {
                memory[i - 1].size += memory[i].size;
                for (int j = i; j < 99; j++) {
                    memory[j] = memory[j + 1];
                }
            }
            if (i < 99 && memory[i + 1].isFree) {
                memory[i].size += memory[i + 1].size;
                for (int j = i + 1; j < 99; j++) {
                    memory[j] = memory[j + 1];
                }
            }
            break;
        }
    }
}

int main() {
    MemoryBlock memory[100];
    int totalSize = 1000;
    initializeMemory(memory, totalSize);

    int processSize = 100;
    int start = allocateMemory(memory, totalSize, processSize);
    printf("Allocated memory at: %d\n", start);

    freeMemory(memory, start);
    printf("Freed memory at: %d\n", start);

    return 0;
}