用c语言实现按最先适应算法设计主存分配和回收的程序。

以下是一个简单的按最先适应算法设计主存分配和回收的C语言程序：

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

#define MEM_SIZE 100 // 总内存大小

// 内存块结构体定义
typedef struct memory_block {
    int start; // 内存块起始位置
    int end;   // 内存块结束位置
    int size;  // 内存块大小
    struct memory_block *next;
} memory_block;

// 内存块头指针
memory_block *head = NULL;

// 初始化内存块
void init_memory_block() {
    head = (memory_block *)malloc(sizeof(memory_block));
    head->start = 0;
    head->end = MEM_SIZE - 1;
    head->size = MEM_SIZE;
    head->next = NULL;
}

// 显示内存块分配情况
void show_memory_block() {
    memory_block *p = head;
    printf("Memory Block Allocation:\n");
    while (p != NULL) {
        printf("Start: %d, End: %d, Size: %d\n", p->start, p->end, p->size);
        p = p->next;
    }
}

// 按最先适应算法分配内存
int allocate_memory(int size) {
    memory_block *p = head;
    while (p != NULL) {
        if (p->size >= size) {
            // 分配内存
            memory_block *new_block = (memory_block *)malloc(sizeof(memory_block));
            new_block->start = p->start;
            new_block->end = p->start + size - 1;
            new_block->size = size;
            new_block->next = NULL;

            // 更新剩余内存块
            p->start += size;
            p->size -= size;

            // 插入新的内存块
            new_block->next = p->next;
            p->next = new_block;

            return new_block->start;
        }
        p = p->next;
    }
    return -1; // 分配失败
}

// 回收内存
void free_memory(int start) {
    memory_block *p = head;
    while (p != NULL) {
        if (p->start == start) {
            // 合并相邻的空闲内存块
            if (p->next != NULL && p->next->start == p->end + 1) {
                p->size += p->next->size;
                memory_block *tmp = p->next;
                p->next = tmp->next;
                free(tmp);
            }
            if (p->start != 0 && p->end != MEM_SIZE - 1 && p->start - 1 == p->prev->end) {
                p->prev->size += p->size;
                p->prev->next = p->next;
                if (p->next != NULL) {
                    p->next->prev = p->prev;
                }
                free(p);
            }
            if (p->start == 0) {
                head = p->next;
                free(p);
            }
            if (p->end == MEM_SIZE - 1) {
                p->prev->next = NULL;
                free(p);
            }
            return;
        }
        p = p->next;
    }
}

int main() {
    init_memory_block();
    show_memory_block();

    int start1 = allocate_memory(10);
    printf("Allocate 10 bytes from %d\n", start1);
    show_memory_block();

    int start2 = allocate_memory(20);
    printf("Allocate 20 bytes from %d\n", start2);
    show_memory_block();

    free_memory(start1);
    printf("Free memory from %d\n", start1);
    show_memory_block();

    int start3 = allocate_memory(5);
    printf("Allocate 5 bytes from %d\n", start3);
    show_memory_block();

    return 0;
}

程序中，首先定义了一个内存块结构体，包括内存块的起始位置、结束位置和大小等信息。然后定义了一个头指针head，用于指向内存块链表的头部。

程序中实现了如下函数：

- init_memory_block()：初始化内存块，将总内存大小分配给头结点。
- show_memory_block()：显示内存块分配情况。
- allocate_memory()：按最先适应算法分配内存，遍历内存块链表，找到第一个可用的内存块，并将其分割成两个内存块，一个是新分配的内存块，另一个是剩余的内存块。
- free_memory()：回收内存，遍历内存块链表，找到要回收的内存块，然后合并相邻的空闲内存块。

在main()函数中，先调用init_memory_block()函数初始化内存块，然后调用show_memory_block()函数显示内存块分配情况。接着，调用allocate_memory()函数分配内存，显示内存块分配情况。再调用free_memory()函数回收内存，显示内存块分配情况。最后再次调用allocate_memory()函数分配内存，显示内存块分配情况。

注：该程序是一个简单的示例，仅供参考，实际应用中可能需要更加完善的内存管理策略。