存储管理动态分区分配及回收算法代码

以下是一个基于首次适应算法的动态分区分配及回收的代码示例：

#define MAX_MEMORY_SIZE 1000 // 内存大小
int memory[MAX_MEMORY_SIZE]; // 内存空间
int memory_size = MAX_MEMORY_SIZE; // 可用内存大小

// 内存块结构体
typedef struct memory_block {
    int start_address;  // 起始地址
    int size;           // 大小
    struct memory_block *next; // 下一个内存块指针
} MemoryBlock;

// 内存块链表头指针
MemoryBlock *memory_head = NULL;

// 初始化内存
void init_memory() {
    memory_head = (MemoryBlock *)malloc(sizeof(MemoryBlock));
    memory_head->start_address = 0;
    memory_head->size = MAX_MEMORY_SIZE;
    memory_head->next = NULL;
}

// 首次适应算法分配内存
int allocate_memory(int size) {
    MemoryBlock *p, *prev = NULL;
    for (p = memory_head; p != NULL; prev = p, p = p->next) {
        if (p->size >= size) {
            // 找到可用内存块
            int start_address = p->start_address;
            p->start_address += size;
            p->size -= size;
            if (p->size == 0) {
                // 内存块大小为0，删除它
                if (prev == NULL) {
                    memory_head = p->next;
                } else {
                    prev->next = p->next;
                }
                free(p);
            }
            return start_address;
        }
    }
    // 没有可用内存块
    return -1;
}

// 回收内存
void deallocate_memory(int start_address, int size) {
    MemoryBlock *p, *prev = NULL;
    for (p = memory_head; p != NULL; prev = p, p = p->next) {
        if (start_address < p->start_address) {
            // 新内存块在当前内存块之前，插入新内存块
            MemoryBlock *new_block = (MemoryBlock *)malloc(sizeof(MemoryBlock));
            new_block->start_address = start_address;
            new_block->size = size;
            new_block->next = p;
            if (prev == NULL) {
                memory_head = new_block;
            } else {
                prev->next = new_block;
            }
            // 合并相邻内存块
            if (new_block->start_address + new_block->size == new_block->next->start_address) {
                new_block->size += new_block->next->size;
                new_block->next = new_block->next->next;
                free(p);
            }
            if (prev != NULL && prev->start_address + prev->size == new_block->start_address) {
                prev->size += new_block->size;
                prev->next = new_block->next;
                free(new_block);
            }
            return;
        }
    }
    // 新内存块在所有内存块之后，插入新内存块
    MemoryBlock *new_block = (MemoryBlock *)malloc(sizeof(MemoryBlock));
    new_block->start_address = start_address;
    new_block->size = size;
    new_block->next = NULL;
    prev->next = new_block;
    // 合并相邻内存块
    if (prev->start_address + prev->size == new_block->start_address) {
        prev->size += new_block->size;
        prev->next = new_block->next;
        free(new_block);
    }
}

这段代码实现了动态分区分配及回收的基本功能，使用了链表来管理内存块，使用了首次适应算法来分配内存块，同时实现了内存块的合并和删除。