基本分段管理方法，采用最佳适应算法分配内存的代码

下面是基本分段管理方法，采用最佳适应算法分配内存的代码示例：

#include <stdio.h>
#include <stdlib.h>
#define MAX 20

int mem[MAX], hole[MAX], pid[MAX], n, m;

void init() {
    int i;
    for (i = 0; i < MAX; i++)
        mem[i] = -1;
}

void display_mem() {
    int i;
    printf("\nMemory: ");
    for (i = 0; i < MAX; i++)
        printf("[%d] ", mem[i]);
    printf("\n");
}

void display_holes() {
    int i;
    printf("\nHoles: ");
    for (i = 0; i < n; i++)
        printf("[%d:%d] ", hole[i], pid[i]);
    printf("\n");
}

int allocate(int p, int s) {
    int i, j, min, index;
    for (i = 0; i < n; i++) {
        if (pid[i] == -1 && hole[i] >= s) {
            pid[i] = p;
            for (j = 0; j < s; j++)
                mem[hole[i]+j] = p;
            return 1;
        }
    }
    min = MAX;
    index = -1;
    for (i = 0; i < n; i++) {
        if (pid[i] == -1 && hole[i] < min && hole[i] >= s) {
            min = hole[i];
            index = i;
        }
    }
    if (index != -1) {
        pid[index] = p;
        for (j = 0; j < s; j++)
            mem[hole[index]+j] = p;
        return 1;
    }
    return 0;
}

void deallocate(int p) {
    int i, j;
    for (i = 0; i < MAX; i++) {
        if (mem[i] == p)
            mem[i] = -1;
    }
    for (i = 0; i < n; i++) {
        if (pid[i] == p) {
            pid[i] = -1;
            for (j = hole[i]; j < MAX && mem[j] == -1; j++)
                ;
            hole[i] = j;
            break;
        }
    }
}

int main() {
    int choice, p, s;
    init();
    printf("\nEnter number of holes: ");
    scanf("%d", &n);
    printf("\nEnter memory holes:\n");
    for (int i = 0; i < n; i++) {
        printf("\nHole %d: ", i+1);
        scanf("%d", &hole[i]);
        pid[i] = -1;
    }
    while (1) {
        printf("\n1. Allocate Memory\n2. Deallocate Memory\n3. Display Memory\n4. Exit\nEnter your choice: ");
        scanf("%d", &choice);
        switch (choice) {
            case 1:
                printf("\nEnter process id: ");
                scanf("%d", &p);
                printf("\nEnter memory size: ");
                scanf("%d", &s);
                if (allocate(p, s))
                    printf("\nMemory allocated successfully!\n");
                else
                    printf("\nMemory allocation failed!\n");
                display_mem();
                display_holes();
                break;
            case 2:
                printf("\nEnter process id to deallocate: ");
                scanf("%d", &p);
                deallocate(p);
                printf("\nMemory deallocated successfully!\n");
                display_mem();
                display_holes();
                break;
            case 3:
                display_mem();
                display_holes();
                break;
            case 4:
                exit(0);
                break;
            default:
                printf("\nInvalid choice!\n");
        }
    }
    return 0;
}

在上述代码中，我们首先定义了一个大小为 MAX 的数组 mem 来表示内存空间，以及一个大小为 MAX 的数组 hole 来表示内存空洞的起始位置。我们还定义了一个大小为 MAX 的数组 pid 来表示每个内存空洞中所分配的进程的编号。初始化时将 pid 数组中所有元素置为 -1，表示所有内存空洞都是空的。

在 allocate 函数中，首先遍历所有未分配的内存空洞，找到第一个满足空洞大小大于等于进程需要的内存大小的空洞，然后将该空洞分配给进程。如果没有满足条件的空洞，我们就需要采用最佳适应算法，即找到大小最接近进程需要的内存大小的空洞来分配给进程。

在 deallocate 函数中，我们首先将内存中所有分配给该进程的位置都置为 -1，然后遍历所有内存空洞，找到与该进程对应的空洞，并更新该空洞的起始位置。

最后，在主函数中，我们通过输入内存空洞的数量和位置，以及选择要执行的操作（分配内存、释放内存、显示内存状态、退出）来测试我们的内存管理程序。