最佳适应算法的内存分配与释放C语言代码

以下是一个简单的最佳适应算法的内存分配与释放的C语言代码：

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

#define MAX_MEM_SIZE 1024

typedef struct mem_block {
    int start;
    int size;
} MemBlock;

// 内存块数组
MemBlock mem_blocks[MAX_MEM_SIZE];

// 内存块数量
int mem_block_count = 0;

// 初始化内存
void init_mem() {
    mem_block_count = 1;
    mem_blocks[0].start = 0;
    mem_blocks[0].size = MAX_MEM_SIZE;
}

// 分配内存
int alloc_mem(int size) {
    int i, j, index = -1, min_size = MAX_MEM_SIZE + 1;
    for (i = 0; i < mem_block_count; i++) {
        if (mem_blocks[i].size >= size && mem_blocks[i].size < min_size) {
            index = i;
            min_size = mem_blocks[i].size;
        }
    }
    if (index == -1) {
        return -1;  // 分配失败
    }
    // 分配内存块
    MemBlock new_block;
    new_block.start = mem_blocks[index].start;
    new_block.size = size;
    mem_blocks[index].start += size;
    mem_blocks[index].size -= size;
    // 插入新的内存块
    for (i = 0; i < mem_block_count; i++) {
        if (mem_blocks[i].start > new_block.start) {
            break;
        }
    }
    for (j = mem_block_count; j > i; j--) {
        mem_blocks[j] = mem_blocks[j - 1];
    }
    mem_blocks[i] = new_block;
    mem_block_count++;
    return new_block.start;
}

// 释放内存
void free_mem(int start, int size) {
    int i, j, index = -1;
    // 查找内存块
    for (i = 0; i < mem_block_count; i++) {
        if (mem_blocks[i].start == start) {
            index = i;
            break;
        }
    }
    if (index == -1) {
        return;  // 释放失败
    }
    // 合并内存块
    mem_blocks[index].size += size;
    if (index < mem_block_count - 1 && mem_blocks[index].start + mem_blocks[index].size == mem_blocks[index + 1].start) {
        mem_blocks[index].size += mem_blocks[index + 1].size;
        for (j = index + 1; j < mem_block_count - 1; j++) {
            mem_blocks[j] = mem_blocks[j + 1];
        }
        mem_block_count--;
    }
    if (index > 0 && mem_blocks[index - 1].start + mem_blocks[index - 1].size == mem_blocks[index].start) {
        mem_blocks[index - 1].size += mem_blocks[index].size;
        for (j = index; j < mem_block_count - 1; j++) {
            mem_blocks[j] = mem_blocks[j + 1];
        }
        mem_block_count--;
    }
}

int main() {
    init_mem();
    int mem1 = alloc_mem(100);
    int mem2 = alloc_mem(200);
    int mem3 = alloc_mem(50);
    free_mem(mem2, 200);
    int mem4 = alloc_mem(150);
    return 0;
}

在这个代码中，我们定义了一个`MemBlock`结构体来表示内存块，包括起始地址和大小。我们使用一个数组`mem_blocks`来存储所有的内存块，使用`mem_block_count`来记录内存块的数量。在`init_mem()`函数中，我们初始化了一块大小为`MAX_MEM_SIZE`的内存块。在`alloc_mem()`函数中，我们遍历所有内存块，找到大小大于等于所需的内存大小并且最小的内存块，然后将其拆分成两个内存块，一个用来分配，一个用来剩余。在`free_mem()`函数中，我们根据指定的起始地址和大小查找内存块，并将其与相邻的内存块合并。在主函数中，我们简单地使用这些函数来分配和释放内存。

需要注意的是，这个代码只是一个简单的示例，实际上最佳适应算法还有很多细节需要考虑，比如如何避免内存碎片等问题。