用c语言实现最佳适应算法

最佳适应算法是一种内存分配算法，其分配的内存块大小与请求的内存块大小最接近，能够最大化利用内存空间，以下是使用 C 语言实现最佳适应算法的示例代码：

// 定义内存块结构体
typedef struct node {
    int size;  // 内存块大小
    int status;  // 内存块状态，0 表示未分配，1 表示已分配
    struct node *prev;  // 前驱指针
    struct node *next;  // 后继指针
} MemoryBlock;

MemoryBlock *head;  // 内存块链表头指针

// 初始化内存块链表
void initMemory() {
    head = (MemoryBlock *)malloc(sizeof(MemoryBlock));
    head->size = 0;
    head->status = 0;
    head->prev = NULL;
    head->next = NULL;
}

// 分配内存块
void *allocMemory(int size) {
    MemoryBlock *p = head->next;
    MemoryBlock *bestFit = NULL;
    int minDiff = INT_MAX;  // 最小差值
    while (p) {
        if (!p->status && p->size >= size) {
            int diff = p->size - size;
            if (diff < minDiff) {
                bestFit = p;
                minDiff = diff;
            }
        }
        p = p->next;
    }
    if (bestFit) {
        if (bestFit->size == size) {
            bestFit->status = 1;
            return (void *)(bestFit + 1);
        } else {
            MemoryBlock *newBlock = (MemoryBlock *)malloc(sizeof(MemoryBlock));
            newBlock->size = size;
            newBlock->status = 1;
            newBlock->prev = bestFit;
            newBlock->next = bestFit->next;
            bestFit->next = newBlock;
            if (newBlock->next) {
                newBlock->next->prev = newBlock;
            }
            bestFit->size -= size;
            return (void *)(newBlock + 1);
        }
    }
    return NULL;
}

// 释放内存块
void freeMemory(void *ptr) {
    MemoryBlock *p = (MemoryBlock *)ptr - 1;
    p->status = 0;
    MemoryBlock *prevBlock = p->prev;
    MemoryBlock *nextBlock = p->next;
    if (prevBlock && !prevBlock->status) {
        prevBlock->size += p->size;
        prevBlock->next = nextBlock;
        if (nextBlock) {
            nextBlock->prev = prevBlock;
        }
        free(p);
        p = prevBlock;
    }
    if (nextBlock && !nextBlock->status) {
        p->size += nextBlock->size;
        p->next = nextBlock->next;
        if (nextBlock->next) {
            nextBlock->next->prev = p;
        }
        free(nextBlock);
    }
}

在这个示例代码中，我们使用了双向链表来存储内存块，每个内存块有三个属性：大小、状态和前驱后继指针。在初始化时，我们创建一个大小为 0 的头节点，并将其设置为链表的头指针。在分配内存时，我们遍历链表，找到最接近请求大小的空闲内存块，并将其分配出去。如果该内存块大小正好等于请求大小，则直接将其标记为已分配；否则，我们将其拆分成两个内存块，一个已分配，一个未分配，并将它们插入到链表中。在释放内存时，我们首先将该内存块标记为未分配，并检查其前驱和后继内存块的状态，如果它们也是未分配的，则将它们合并成一个内存块。