编写C语言程序，模拟实现首次适应算法的内存块分配和回收，要求每次分配和回收后显示出空闲分区和已分配分区的情况。假设初始状态下，可用的内存空间为640KB。并充分解释该代码。

下面是一个简单的C语言程序，模拟实现首次适应算法内存块的分配和回收。该程序可以通过输入命令来对内存块进行分配和回收，并在每次分配和回收后显示出空闲分区和已分配分区的情况。该程序基于首次适应算法，即从内存起始地址开始，首先找到第一个能够满足需求的空闲分区进行分配。

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

#define MEM_SIZE 640 // 内存总大小
#define MIN_SIZE 4 // 最小可分配内存块大小

int mem[MEM_SIZE]; // 内存空间数组
int alloc[MEM_SIZE]; // 已分配分区标记数组

// 初始化内存
void init_mem() {
    for (int i = 0; i < MEM_SIZE; i++) {
        mem[i] = 0;
        alloc[i] = 0;
    }
    mem[0] = MEM_SIZE; // 初始状态下整块内存空闲
}

// 显示内存分配情况
void show_mem() {
    int free_size = 0; // 空闲分区大小
    int alloc_size = 0; // 已分配分区大小
    printf("Free memory:\n");
    for (int i = 0; i < MEM_SIZE; i++) {
        if (mem[i] == 0 && i + MIN_SIZE - 1 < MEM_SIZE) {
            // 发现空闲分区
            int j = i;
            while (mem[j] == 0 && j < MEM_SIZE) {
                free_size++;
                j++;
            }
            printf("    [%d, %d] : %dKB\n", i, j - 1, free_size);
            i = j - 1;
            free_size = 0;
        }
    }
    printf("Allocated memory:\n");
    for (int i = 0; i < MEM_SIZE; i++) {
        if (alloc[i] == 1) {
            // 发现已分配分区
            int j = i;
            while (alloc[j] == 1 && j < MEM_SIZE) {
                alloc_size++;
                j++;
            }
            printf("    [%d, %d] : %dKB\n", i, j - 1, alloc_size);
            i = j - 1;
            alloc_size = 0;
        }
    }
}

// 内存分配
void mem_alloc(int size) {
    // 从内存起始地址开始寻找空闲分区
    for (int i = 0; i < MEM_SIZE; i++) {
        if (mem[i] == 0 && i + size - 1 < MEM_SIZE) {
            // 发现空闲分区
            int j = i;
            while (mem[j] == 0 && j < MEM_SIZE) {
                if (j - i + 1 == size) {
                    // 找到合适的空闲分区
                    for (int k = i; k <= j; k++) {
                        mem[k] = size;
                        alloc[k] = 1;
                    }
                    printf("Allocated memory [%d, %d] : %dKB\n", i, j, size);
                    return;
                }
                j++;
            }
            i = j - 1;
        }
    }
    printf("Cannot allocate memory of %dKB\n", size);
}

// 内存回收
void mem_free(int start) {
    int size = mem[start];
    for (int i = start; i < start + size; i++) {
        mem[i] = 0;
        alloc[i] = 0;
    }
    printf("Freed memory [%d, %d] : %dKB\n", start, start + size - 1, size);
}

int main() {
    init_mem();
    show_mem();
    char cmd;
    int size, start;
    while (1) {
        printf("Command (a:alloc, f:free, q:quit) : ");
        scanf(" %c", &cmd);
        if (cmd == 'q') {
            break;
        }
        switch (cmd) {
            case 'a':
                printf("Alloc size (KB) : ");
                scanf("%d", &size);
                mem_alloc(size);
                break;
            case 'f':
                printf("Free start address : ");
                scanf("%d", &start);
                mem_free(start);
                break;
            default:
                printf("Invalid command!\n");
                break;
        }
        show_mem();
    }
    return 0;
}

程序中定义了两个数组`mem`和`alloc`，分别表示内存空间和已分配分区的标记。在程序初始化时，将`mem`和`alloc`数组中的所有元素都初始化为0，表示初始状态下整块内存空闲。程序中定义了三个函数`init_mem()`、`show_mem()`、`mem_alloc()`和`mem_free()`，分别用于初始化内存、显示内存分配情况、内存分配和内存回收。

`init_mem()`函数用于初始化内存，将`mem`和`alloc`数组中的所有元素都初始化为0，表示初始状态下整块内存空闲，同时将`mem`数组中第一个元素赋值为`MEM_SIZE`，表示整块内存可用。

`show_mem()`函数用于显示内存分配情况。首先遍历`mem`数组，找到所有的空闲分区，并输出其起始地址、结束地址和大小。接着遍历`alloc`数组，找到所有的已分配分区，并输出其起始地址、结束地址和大小。

`mem_alloc()`函数用于内存分配。该函数采用首次适应算法，即从内存起始地址开始，首先找到第一个能够满足需求的空闲分区进行分配。遍历`mem`数组，找到第一个空闲分区，并计算出其大小，如果该空闲分区大小大于等于需求大小，则将其分配给请求。将`mem`数组中对应分区的元素赋值为请求大小，将`alloc`数组中对应分区的元素赋值为1，表示已分配。如果找不到合适的空闲分区，则输出提示信息。

`mem_free()`函数用于内存回收。该函数接收一个起始地址，通过该地址找到被回收分区的大小，并将`mem`和`alloc`数组中对应分区的元素都赋值为0，表示该分区空闲。

在`main()`函数中，程序首先调用`init_mem()`函数进行内存初始化，并调用`show_mem()`函数显示内存分配情况。接着进入一个无限循环，每次循环根据用户输入的命令进行内存分配或回收，并调用`show_mem()`函数显示内存分配情况。如果用户输入`q`命令，则退出循环并结束程序。

总之，该程序模拟了一个简单的内存分配与回收系统，采用首次适应算法进行内存分配。