用C语言实现首次适应算法的动态分区分配过程malloc()和回收过程free()。其中，空闲分区通过空闲区说明表；在进行内存分配时，系统优先使用空闲区低端的空间。

好的，我了解了你的问题。下面是用C语言实现首次适应算法的动态分区分配过程malloc()和回收过程free()的示例代码：

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

// 定义空闲区说明表的结构体
typedef struct free_block_t {
    int size;  // 空闲区大小
    int start; // 空闲区起始地址
    struct free_block_t *next; // 指向下一个空闲区说明表项
} free_block;

// 定义全局变量，表示内存大小和分配起始地址
#define MAX_MEM_SIZE 1000
char mem[MAX_MEM_SIZE];
int start = 0;

// 定义全局变量，表示空闲区说明表的头指针
free_block *free_head = NULL;

// 初始化空闲区说明表，将整个内存块作为一个空闲区
void init_free_list() {
    free_head = (free_block *)malloc(sizeof(free_block));
    free_head->size = MAX_MEM_SIZE;
    free_head->start = 0;
    free_head->next = NULL;
}

// 将空闲区说明表打印出来
void print_free_list() {
    printf("Free List: ");
    free_block *p = free_head;
    while (p != NULL) {
        printf("[%d, %d] ", p->start, p->size);
        p = p->next;
    }
    printf("\n");
}

// 从空闲区说明表中查找满足要求的空闲块
free_block *find_free_block(int size) {
    free_block *p = free_head;
    while (p != NULL) {
        if (p->size >= size) {
            return p;
        }
        p = p->next;
    }
    return NULL;
}

// 对空闲区说明表进行插入操作
void insert_free_block(free_block *new_block) {
    free_block *p = free_head;
    while (p->next != NULL) {
        if (p->next->start > new_block->start) {
            break;
        }
        p = p->next;
    }
    new_block->next = p->next;
    p->next = new_block;
}

// 动态分区分配过程malloc()
void *malloc_first_fit(int size) {
    free_block *free_block_ptr = find_free_block(size);
    if (free_block_ptr == NULL) {
        printf("Error: Cannot allocate memory.\n");
        return NULL;
    }
    int old_size = free_block_ptr->size;
    int old_start = free_block_ptr->start;
    int new_size = old_size - size;
    int new_start = old_start + size;
    // 从空闲区说明表中删除已分配的空闲块
    if (old_size == size) {
        free_block *p = free_head;
        while (p->next != free_block_ptr) {
            p = p->next;
        }
        p->next = free_block_ptr->next;
        free(free_block_ptr);
    } else {
        free_block_ptr->size = size;
        free_block_ptr->start = old_start;
        if (new_size > 0) {
            free_block *new_block = (free_block *)malloc(sizeof(free_block));
            new_block->size = new_size;
            new_block->start = new_start;
            insert_free_block(new_block);
        }
    }
    // 返回分配的内存块起始地址
    return (void *)&mem[old_start];
}

// 动态分区回收过程free()
void free_first_fit(void *ptr, int size) {
    int start_addr = (int)((char *)ptr - mem);
    free_block *new_block = (free_block *)malloc(sizeof(free_block));
    new_block->size = size;
    new_block->start = start_addr;
    insert_free_block(new_block);
}

// 测试程序
int main() {
    init_free_list();
    print_free_list();
    char *p1 = (char *)malloc_first_fit(100);
    printf("Allocated 100 bytes at %d.\n", (int)(p1 - mem));
    print_free_list();
    char *p2 = (char *)malloc_first_fit(200);
    printf("Allocated 200 bytes at %d.\n", (int)(p2 - mem));
    print_free_list();
    char *p3 = (char *)malloc_first_fit(300);
    printf("Allocated 300 bytes at %d.\n", (int)(p3 - mem));
    print_free_list();
    free_first_fit(p2, 200);
    printf("Freed 200 bytes at %d.\n", (int)(p2 - mem));
    print_free_list();
    char *p4 = (char *)malloc_first_fit(150);
    printf("Allocated 150 bytes at %d.\n", (int)(p4 - mem));
    print_free_list();
    free_first_fit(p1, 100);
    printf("Freed 100 bytes at %d.\n", (int)(p1 - mem));
    print_free_list();
    free_first_fit(p3, 300);
    printf("Freed 300 bytes at %d.\n", (int)(p3 - mem));
    print_free_list();
    return 0;
}

这段代码实现了首次适应算法的动态分区分配过程malloc()和回收过程free()，并且使用空闲区说明表来管理空闲块。在进行内存分配时，系统会优先使用空闲区低端的空间。你可以根据需要自行更改代码。