在lunix系统钟，编写C程序，模拟实现首次适应算法的内存块分配与回收，要求每次分配与回收后显示出空闲分区和已分配分区的情况。假设在初始状态下可用的内存空间为640KB。

好的，我明白了您的问题。首先，您需要了解首次适应算法的内存管理原理，然后编写C程序来模拟实现该算法。以下是一个简单的解决方案：

1.定义一个结构体来表示内存块：

typedef struct _mem_block{
    int id;             // 内存块id
    int size;           // 内存块大小
    int isFree;         // 内存块是否空闲：1-空闲，0-已分配
    struct _mem_block *next;    // 指向下一个内存块
} MemBlock;

2.定义一个函数来初始化内存，分配一块大小为640KB的空间：

MemBlock* initMemory(){
    MemBlock *head = (MemBlock*)malloc(sizeof(MemBlock));
    head->id = 0;
    head->size = 640;
    head->isFree = 1;
    head->next = NULL;
    return head;
}

3.定义一个函数来实现首次适应算法内存块分配：

MemBlock* allocateMemory(MemBlock *head, int size){
    MemBlock *p = head;
    while(p!=NULL){
        if(p->isFree==1 && p->size>=size){    // 找到空闲的内存块
            MemBlock *newBlock = (MemBlock*)malloc(sizeof(MemBlock));
            newBlock->id = p->id+1;
            newBlock->size = size;
            newBlock->isFree = 0;
            newBlock->next = NULL;
            p->size -= size;
            if(p->size == 0){    // 如果剩余部分大小为0，则删除该块
                MemBlock *tmp = p->next;
                free(p);
                head = tmp;
            }
            else{
                newBlock->next = p->next;
                p->next = newBlock;
            }
            return newBlock;
        }
        p = p->next;
    }
    printf("No enough memory!\n");    // 没有可用空间
    return NULL;
}

4.定义一个函数来实现内存块回收：

void freeMemory(MemBlock *head, int id){
    MemBlock *p = head;
    while(p!=NULL){
        if(p->id == id){    // 找到对应id的内存块
            if(p->isFree == 0){    // 需要回收的内存块
                p->isFree = 1;
                // 合并相邻空闲内存块
                if(p->next!=NULL && p->next->isFree){
                    p->size += p->next->size;
                    MemBlock *tmp = p->next->next;
                    free(p->next);
                    p->next = tmp;
                }
                if(p->id!=0 && p->isFree && p->next!=NULL && p->next->isFree && p->next->id!=0){
                    p->size += p->next->size;
                    MemBlock *tmp = p->next->next;
                    free(p->next);
                    p->next = tmp;
                }
                break;
            }
            else{
                printf("This block has already been freed!\n");
                break;
            }
        }
        p = p->next;
    }
    if(p == NULL){
        printf("Can not find such block!\n");
    }
}

5.定义一个函数来显示当前内存块状态：

void displayMemory(MemBlock *head){
    printf("Free Blocks:\n");
    MemBlock *p = head;
    while(p!=NULL){
        if(p->isFree){
            printf("ID:%d  Size:%dKB\n",p->id,p->size);
        }
        p = p->next;
    }
    printf("Allocated Blocks:\n");
    p = head;
    while(p!=NULL){
        if(!p->isFree){
            printf("ID:%d  Size:%dKB\n",p->id,p->size);
        }
        p = p->next;
    }
}

6.主函数通过函数调用来演示内存块分配与回收的过程，生成不同的内存块状态：

int main(){
    MemBlock *head = initMemory();    // 初始化内存块
    displayMemory(head);                // 显示当前内存块状态

    MemBlock *blk1 = allocateMemory(head, 100);    // 分配100KB内存块
    displayMemory(head);

    MemBlock *blk2 = allocateMemory(head, 200);    // 分配200KB内存块
    displayMemory(head);

    freeMemory(head, blk1->id);    // 回收内存块
    displayMemory(head);

    MemBlock *blk3 = allocateMemory(head, 150);    // 分配150KB内存块
    displayMemory(head);

    MemBlock *blk4 = allocateMemory(head, 50);    // 分配50KB内存块
    displayMemory(head);

    freeMemory(head, blk2->id);    // 回收内存块
    displayMemory(head);

    freeMemory(head, blk4->id);    // 回收内存块
    displayMemory(head);

    freeMemory(head, blk3->id);    // 回收内存块
    displayMemory(head);

    return 0;
}

当您运行以上代码时，您将看到控制台输出当前内存块状态。然后，它将模拟分配和回收内存块，您可以看到随着分配和回收，内存块的状态如何发生变化。最后，它将显示内存中块的状态。