动态分区分配算法代码c语言，并写出注释

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

#define MAX 100 //最大分区数

struct node{ //定义分区结构体
    int id; //分区编号
    int sp; //分区起始地址
    int ep; //分区结束地址
    int longsize; //分区长度
}a[MAX],b[MAX]; //a为作业分区，b为空闲分区

void Init(int anum,int bnum,int size){ //初始化分区
    a[0].id = 1;
    a[0].sp = 0;
    a[0].ep = size-1;
    a[0].longsize = size;
    for(int i=1;i<anum;i++){
        a[i].id = i+1;
        a[i].sp = -1;
        a[i].ep = -1;
        a[i].longsize = -1;
    }
    for(int i=0;i<bnum;i++){
        b[i].id = i+1;
        b[i].sp = -1;
        b[i].ep = -1;
        b[i].longsize = -1;
    }
}

void FirstFit(int anum,int bnum,int size,int jobsize){ //首次适应算法
    int flag = 0; //标记是否分配成功
    for(int i=0;i<bnum;i++){
        if(b[i].longsize >= jobsize){ //找到第一个满足要求的空闲分区
            flag = 1;
            a[anum].id = anum+1;
            a[anum].sp = b[i].sp;
            a[anum].ep = b[i].sp+jobsize-1;
            a[anum].longsize = jobsize;
            b[i].sp += jobsize;
            b[i].longsize -= jobsize;
            if(b[i].longsize == 0){ //如果空闲分区被用完，删除该分区
                for(int j=i;j<bnum-1;j++){
                    b[j] = b[j+1];
                }
                b[bnum-1].id = -1;
                b[bnum-1].sp = -1;
                b[bnum-1].ep = -1;
                b[bnum-1].longsize = -1;
                bnum--;
            }
            anum++;
            break;
        }
    }
    if(flag == 0){ //分配失败
        printf("分配失败！\n");
    }
    else{ //分配成功
        printf("分配成功！\n");
        printf("分配后的作业分区表：\n");
        printf("作业分区 起始地址 结束地址 长度\n");
        for(int i=0;i<anum;i++){
            printf(" %d %d %d %d\n",a[i].id,a[i].sp,a[i].ep,a[i].longsize);
        }
        printf("分配后的空闲分区表：\n");
        printf("空闲分区 起始地址 结束地址 长度\n");
        for(int i=0;i<bnum;i++){
            printf(" %d %d %d %d\n",b[i].id,b[i].sp,b[i].ep,b[i].longsize);
        }
    }
}

void BestFit(int anum,int bnum,int size,int jobsize){ //最佳适应算法
    int flag = 0; //标记是否分配成功
    int min = size+1; //记录最小的空闲分区长度
    int index = -1; //记录最小的空闲分区下标
    for(int i=0;i<bnum;i++){
        if(b[i].longsize >= jobsize && b[i].longsize < min){ //找到满足要求的最小空闲分区
            flag = 1;
            min = b[i].longsize;
            index = i;
        }
    }
    if(flag == 1){ //分配成功
        a[anum].id = anum+1;
        a[anum].sp = b[index].sp;
        a[anum].ep = b[index].sp+jobsize-1;
        a[anum].longsize = jobsize;
        b[index].sp += jobsize;
        b[index].longsize -= jobsize;
        if(b[index].longsize == 0){ //如果空闲分区被用完，删除该分区
            for(int j=index;j<bnum-1;j++){
                b[j] = b[j+1];
            }
            b[bnum-1].id = -1;
            b[bnum-1].sp = -1;
            b[bnum-1].ep = -1;
            b[bnum-1].longsize = -1;
            bnum--;
        }
        anum++;
        printf("分配成功！\n");
        printf("分配后的作业分区表：\n");
        printf("作业分区 起始地址 结束地址 长度\n");
        for(int i=0;i<anum;i++){
            printf(" %d %d %d %d\n",a[i].id,a[i].sp,a[i].ep,a[i].longsize);
        }
        printf("分配后的空闲分区表：\n");
        printf("空闲分区 起始地址 结束地址 长度\n");
        for(int i=0;i<bnum;i++){
            printf(" %d %d %d %d\n",b[i].id,b[i].sp,b[i].ep,b[i].longsize);
        }
    }
    else{ //分配失败
        printf("分配失败！\n");
    }
}

void Release(int anum,int bnum){ //回收分区
    int id;
    printf("请输入要回收的分区编号：");
    scanf("%d",&id);
    int flag = 0; //标记是否找到要回收的分区
    for(int i=0;i<anum;i++){
        if(a[i].id == id){ //找到要回收的分区
            flag = 1;
            for(int j=0;j<bnum;j++){
                if(b[j].sp > a[i].ep){ //找到要回收的分区后面的空闲分区
                    for(int k=bnum;k>j;k--){ //将空闲分区后移
                        b[k] = b[k-1];
                    }
                    b[j].id = bnum+1;
                    b[j].sp = a[i].sp;
                    b[j].ep = a[i].ep;
                    b[j].longsize = a[i].longsize;
                    bnum++;
                    break;
                }
            }
            for(int j=i;j<anum-1;j++){ //将作业分区后移
                a[j] = a[j+1];
            }
            a[anum-1].id = -1;
            a[anum-1].sp = -1;
            a[anum-1].ep = -1;
            a[anum-1].longsize = -1;
            anum--;
            printf("回收成功！\n");
            printf("回收后的作业分区表：\n");
            printf("作业分区 起始地址 结束地址 长度\n");
            for(int i=0;i<anum;i++){
                printf(" %d %d %d %d\n",a[i].id,a[i].sp,a[i].ep,a[i].longsize);
            }
            printf("回收后的空闲分区表：\n");
            printf("空闲分区 起始地址 结束地址 长度\n");
            for(int i=0;i<bnum;i++){
                printf(" %d %d %d %d\n",b[i].id,b[i].sp,b[i].ep,b[i].longsize);
            }
            break;
        }
    }
    if(flag == 0){ //未找到要回收的分区
        printf("未找到要回收的分区！\n");
    }
}

int main(){
    int anum = 1; //作业分区数
    int bnum = 1; //空闲分区数
    int size; //主存大小
    int jobsize; //作业大小
    int choice; //用户选择的操作
    printf("请输入主存大小：");
    scanf("%d",&size);
    printf("请输入作业大小：");
    scanf("%d",&jobsize);
    Init(anum,bnum,size); //初始化分区
    while(1){
        printf("请选择要进行的操作：\n");
        printf("1.首次适应算法\n");
        printf("2.最佳适应算法\n");
        printf("3.回收分区\n");
        printf("4.退出程序\n");
        printf("请输入操作编号：");
        scanf("%d",&choice);
        switch(choice){
            case 1:
                FirstFit(anum,bnum,size,jobsize); //首次适应算法
                break;
            case 2:
                BestFit(anum,bnum,size,jobsize); //最佳适应算法
                break;
            case 3:
                Release(anum,bnum); //回收分区
                break;
            case 4:
                exit(0); //退出程序
            default:
                printf("输入错误，请重新输入！\n");
                break;
        }
    }
    return 0;
}

注释：
1.定义分区结构体，包括分区编号、起始地址、结束地址和长度。
2.初始化分区，将第一个作业分区设置为整个主存，其余作业分区和空闲分区设置为-1。
3.首次适应算法，遍历空闲分区表，找到第一个满足要求的空闲分区，将其分配给作业分区，更新作业分区表和空闲分区表。
4.最佳适应算法，遍历空闲分区表，找到满足要求的最小空闲分区，将其分配给作业分区，更新作业分区表和空闲分区表。
5.回收分区，输入要回收的分区编号，找到要回收的作业分区，将其释放并合并相邻的空闲分区，更新作业分区表和空闲分区表。
6.主函数，初始化分区，循环执行用户选择的操作，包括首次适应算法、最佳适应算法、回收分区和退出程序。