用c语言实现伙伴算法内存分配器，给出详细注释

伙伴算法是一种常用的内存分配算法，它将一片连续的内存空间不断地分割成大小不同的块，并按照大小分成不同的“伙伴”区块。当需要分配内存时，先从最小的区块开始查找，如果找到了合适大小的块，则直接分配；否则将相邻的“伙伴”区块合并成一个更大的区块，然后再次查找。当需要释放内存时，先找到对应的块，然后将其标记为可用，并检查与其相邻的区块是否都是可用的，如果是，则将它们合并成一个更大的区块。下面是基于C语言实现的伙伴算法内存分配器。

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

#define MAX_ORDER 10 // 最大的块次数
#define BLOCK_SIZE (1 << MAX_ORDER) // 最大块大小
#define MIN_ORDER 4 // 最小的块次数
#define MIN_SIZE (1 << MIN_ORDER) // 最小块大小
#define BLOCK_COUNT (1 << (MAX_ORDER - MIN_ORDER)) // 块数目

typedef struct block {
    int order; // 块次数
    struct block *next; // 下一块
} block;

static block *free_lists[MAX_ORDER + 1]; // 空闲块链表

// 初始化空闲块链表
static void init_free_lists() {
    int i;
    for (i = 0; i <= MAX_ORDER; i++) {
        free_lists[i] = NULL;
    }
}

// 分割块
static block *split_block(block *b, int order) {
    int i;
    for (i = order; i > b->order; i--) {
        block *new_b = (block *)((char *)b + (1 << (i - 1)));
        new_b->order = i - 1;
        new_b->next = free_lists[i - 1];
        free_lists[i - 1] = new_b;
    }
    b->order = order;
    return b;
}

// 合并块
static block *merge_block(block *b) {
    int order = b->order;
    block *buddy = (block *)((char *)b ^ (1 << order));
    if (buddy->order == order && free_lists[order] == buddy) {
        free_lists[order] = buddy->next;
        return merge_block((block *)((char *)b & ~(1 << order)));
    } else {
        b->next = free_lists[order];
        free_lists[order] = b;
        return b;
    }
}

// 分配内存
void *buddy_alloc(size_t size) {
    if (size > BLOCK_SIZE - sizeof(block)) {
        return NULL;
    }
    int order = ceil(log2(size + sizeof(block)));
    for (; order <= MAX_ORDER; order++) {
        if (free_lists[order] != NULL) {
            block *b = free_lists[order];
            free_lists[order] = b->next;
            return (void *)(split_block(b, order) + 1);
        }
    }
    return NULL;
}

// 释放内存
void buddy_free(void *ptr) {
    block *b = (block *)((char *)ptr - sizeof(block));
    merge_block(b);
}

int main(int argc, char *argv[]) {
    init_free_lists();
    void *p1 = buddy_alloc(100);
    void *p2 = buddy_alloc(200);
    void *p3 = buddy_alloc(400);
    void *p4 = buddy_alloc(800);
    void *p5 = buddy_alloc(1600);
    void *p6 = buddy_alloc(3200);
    buddy_free(p4);
    buddy_free(p3);
    buddy_free(p2);
    void *p7 = buddy_alloc(1000);
    void *p8 = buddy_alloc(2000);
    buddy_free(p5);
    buddy_free(p6);
    void *p9 = buddy_alloc(3000);
    void *p10 = buddy_alloc(4000);
    buddy_free(p1);
    buddy_free(p7);
    buddy_free(p8);
    buddy_free(p9);
    buddy_free(p10);
    return 0;
}

在上述代码中，我们首先定义了一个`block`结构体，它表示一个内存块，其中`order`表示块的次数，`next`表示指向下一个内存块的指针。然后定义了一个指针数组`free_lists`，用于存储不同大小的空闲内存块链表。`init_free_lists`函数用于初始化该数组。`split_block`函数用于将一个块分割成大小更小的块，`merge_block`函数用于将两个相邻的空闲块合并成一个更大的块。`buddy_alloc`函数用于分配内存，它首先计算需要的块的次数，然后从对应的空闲块链表中查找是否有合适大小的块，如果有，则分割该块，并返回该块的地址。`buddy_free`函数用于释放内存，它将对应的块标记为可用，并尝试将其与相邻的空闲块合并成更大的块。

在`main`函数中，我们首先初始化空闲块链表，然后分配了6个不同大小的内存块，并释放了其中的三个。接着又分配了两个内存块，并释放了其中的一个。最后又分配了两个内存块，并释放了所有内存块。