动态分区代码

管道程序

#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>
#include <stdlib.h>
int main(void)
{
int fds[2];
pid_t pid;
if(pipe(fds) == -1)
{
perror("pipe error");
exit(1);
}
pid=fork();
if(pid == -1)
{
perror("fork error");
exit(1);
}
if(pid == 0)//parent
{
char buf[1024];
int n;
close(fds[1]);
n = read(fds[0], buf, 1024);//从管道读端读出数据到buf
write(STDOUT_FILENO, "child:",6);
write(STDOUT_FILENO, buf, n);//将读到的数据打印到终端
}
else//child
{
close(fds[0]);
write(fds[1], "hello world\n", 12);//向管道写端写入数据“hello world\n”
wait(NULL);
}
return 0;
}

动态分区程序C

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<math.h>
#define N 10000
int n1;//空闲分区的个数
int n2;//作业区的个数
struct kongxian
{
    int start;  //起址
    int end;    //结束
    int length;  //长度
}kongxian[N];
struct zuoye
{
    int start;  //起址
    int end;   //结束
    int length;  //长度
}zuoye[N];
int cmp1(const void *a, const void *b)
{
    return (*(struct kongxian *)a).start - (*(struct kongxian *)b).start;
}
int cmp2(const void *a, const void *b)
{
    return (*(struct zuoye *)a).start - (*(struct zuoye *)b).start;
}
void init()
{
    n1 = 1;  //初始时只有一个空闲区
    n2 = 0;  //初始没有作业
    kongxian[0].start = 0;
    kongxian[0].end = 511;
    kongxian[0].length = 512;
}
void print1() //打印空闲分区
{
    int i;
    for (i = 0; i<n1; i++)
        printf("空闲分区ID:%d 起止:%d 结束:%d 长度:%d\n", i, kongxian[i].start, kongxian[i].end, kongxian[i].length);
}
void print2() //打印作业分区
{
    int i;
    for (i = 0; i<n2; i++)
        printf("作业分区ID：%d 起止:%d 结束:%d 长度:%d\n", i, zuoye[i].start, zuoye[i].end, zuoye[i].length);
}
int main()
{
    int i, j, t, len, flag, id;
    int front, middle, behind;
    int t1, t2;
    init();
    print1();
    printf("输入1装入新作业，输入0回收作业，输入-1结束\n");
    while (scanf("%d", &t) != EOF)
    {
        if (t == 1)  //装入新作业
        {
            printf("请输入作业的占用空间的长度 ");
            scanf("%d", &len);
            flag = 0;
            for (i = 0; i<n1; i++)
            {
                if (kongxian[i].length >= len)  //首次适应算法
                {
                    flag = 1;
                    break;
                }
            }
            if (!flag)
            {
                printf("内存分配失败\n");
            }
            else
            {
                //将该作业加入作业区里
                zuoye[n2].start = kongxian[i].start;
                zuoye[n2].end = zuoye[n2].start + len;
                zuoye[n2].length = len;
                n2++;  //作业数加1
                if (kongxian[i].length == len) //该分区全部用于分配，删除该空闲分区
                {
                    for (j = i; j<n1 - 1; j++)
                    {
                        kongxian[j].start = kongxian[j + 1].start;
                        kongxian[j].end = kongxian[j + 1].end;
                        kongxian[j].length = kongxian[j + 1].length;
                    }
                    n1--;
                }
                else  //该空闲分区部分用于分配，剩余的留在空闲分区中
                {
                    kongxian[i].start += len;
                    kongxian[i].length -= len;
                }
            }
        }
        else if (t == 0)
        {
            printf("输入要回收的作业ID ");
            scanf("%d", &id);
            front = middle = behind = 0;
            for (i = 0; i<n1; i++)
            {
                if (kongxian[i].start>zuoye[id].end)
                    break;
                if (kongxian[i].end == zuoye[id].start)  //待回收的作业上面有空闲分区
                {
                    front = 1;
                    t1 = i;
                }
                if (kongxian[i].start == zuoye[id].end)  //待回收的作业下面有空闲分区
                {
                    behind = 1;
                    t2 = i;
                }
            }
            if (!front&&!behind)  //待回收的作业上下均没有空闲分区
            {
                kongxian[n1].start = zuoye[id].start;
                kongxian[n1].end = zuoye[id].end;
                kongxian[n1].length = zuoye[id].length;
                n1++;  //空闲分区增加一个
                qsort(kongxian, n1, sizeof(struct kongxian), cmp1); //插入空闲分区后排序
                for (j = id; j<n2 - 1; j++)  //在作业分区中删除该作业
                {
                    zuoye[j].start = zuoye[j + 1].start;
                    zuoye[j].end = zuoye[j + 1].end;
                    zuoye[j].length = zuoye[j + 1].length;
                }
                n2--;
            }
            if (front &&behind)  //待回收的作业上下均有空闲分区
                middle = 1;
            if (front&&!middle)  //合并待回收的作业和上面的空闲分区
            {
                kongxian[t1].end += zuoye[id].length;
                kongxian[t1].length += zuoye[id].length;
                for (j = id; j<n2 - 1; j++)  //在作业分区中删除该作业
                {
                    zuoye[j].start = zuoye[j + 1].start;
                    zuoye[j].end = zuoye[j + 1].end;
                    zuoye[j].length = zuoye[j + 1].length;
                }
                n2--;
            }
            if (middle)  //合并待回收的作业和上下的空闲分区
            {
                kongxian[t1].end = kongxian[t2].end;
                kongxian[t1].length += (zuoye[id].length + kongxian[t2].length);
                //删除空闲分区t2
                for (j = t2; j<n1 - 1; j++)
                {
                    kongxian[j].start = kongxian[j + 1].start;
                    kongxian[j].end = kongxian[j + 1].end;
                    kongxian[j].length = kongxian[j + 1].length;
                }
                n1--;
                for (j = id; j<n2 - 1; j++)  //在作业分区中删除该作业
                {
                    zuoye[j].start = zuoye[j + 1].start;
                    zuoye[j].end = zuoye[j + 1].end;
                    zuoye[j].length = zuoye[j + 1].length;
                }
                n2--;
            }
            if (behind &&!middle) //合并待回收的作业和下面的分区
            {
                kongxian[t2].start -= zuoye[id].length;
                kongxian[t2].length += zuoye[id].length;
                for (j = id; j<n2 - 1; j++)  //在作业分区中删除该作业
                {
                    zuoye[j].start = zuoye[j + 1].start;
                    zuoye[j].end = zuoye[j + 1].end;
                    zuoye[j].length = zuoye[j + 1].length;
                }
                n2--;
            }
        }
        else
        {
            printf("操作结束\n");
            break;
        }
        print1();
        print2();
    }
    return 0;
}

动态分区程序c++

#include<iostream>
#include<stdio.h>
#include<stdlib.h>
#include<windows.h>
using namespace std;
typedef struct freetable
{
    long start; //空闲表起始地址
    long length;    //空闲长度
    long state; //空闲块状态
    struct freetable *next; //下一个空闲区的表头
}freetable;

freetable *flist=NULL,*blist=NULL;  //有两个表，一个表空闲表，一个分配表
long nfree=0;               //用顺序的任务号来标记分配表的头

int initializtion(int i);    //初始化链表，i=1时为空闲区，i=2时分配区
int showlist(int i);         //查看表，i=1时为空闲区，i=2时分配区
int sortlist(int i);         //排序空闲区表，1最先适应算法按照起始地址递增，2最佳适应算法按分区从小到大，3最坏适应算法按分区从大到小
int firstbest(long j,long cnum,long csize); //j:1最先适应算法,2最佳适应算法
int worstfit(long cnum,long csize);     //最坏适应算法
int recover(long cnum);             //回收功能
int menu();                 //菜单
int check(int i,freetable *cc);//检查添加是否有重复

int check(int i,freetable *cc)//检查添加是否有重复
{
    freetable *nn,*p;   //使用两个指针来循环判断。
    long caddress=cc->start,ccsize=cc->length,cstate=cc->state;//令c来接受传进来的参数
    long plast,clast=caddress+ccsize;   //clast为此块的结尾地址
    nn=blist;   //nn为分配表的表头
    p=nn->next; //p为分配表第二个值
    while(p!=NULL)
    {
        plast=p->start+p->length;  //尾地址
        if ( !( (p->start>caddress&&plast>clast)||(p->start<caddress&&plast<clast) ) ) return 0;
        if(i==2) if (p->state==cstate) return 0;//重复了
        p=p->next;
    }
    nn=flist;
    p=nn->next; //空闲表表头
    while (p!=NULL)
    {
        plast=p->start+p->length;
        if ( !( (p->start>caddress&&plast>clast)||(p->start<caddress&&plast<clast) ) ) return 0;
        p=p->next;
    }
    return 1;   //没有重复
}

int initializtion(int i)    //初始化，1空闲区，2分配区
{
    freetable *nn,*p;
    int num,f=0,k;
    do
    {
        if (i==1)
        {
            cout<<"请输入预先设置的空闲区个数：";
            p=flist;
        }else
        {
            cout<<"请输入已分配区分配个数：";
            p=blist;
        }
        cin>>num;
        k=0;
        if (num>0) f=num;
    }while (f<=0);
    if (f)
    {
        if (i==1) cout<<"请依次输入空闲区始址、长度："<<endl;
        else cout<<"请依次输入已分配区始址、长度、进程编号："<<endl;
    }
    while (num--)
    {
        k++;
        nn=(freetable  *)malloc(sizeof(freetable ));
        scanf("%ld%ld",&nn->start,&nn->length);
        if (i==2) scanf("%ld",&nn->state);else nn->state=++nfree;
        if (!check(i,nn))
        {
            cout<<"第"<<k<<"个输入有重复，添加失败"<<endl;
        }else{nn->next=p->next;p->next=nn;}//因为第一个是哨兵节点
    }
    nn=NULL;
    cout<<"end"<<endl;
    return 0;
}
int showlist(int i)//查看表
{
    freetable *nn;
    if(i==1)
    {
        nn=flist->next;
        cout<<"空闲区"<<endl;
    }else if(i==2)
    {
        nn=blist->next;
        cout<<"分配区"<<endl;
    }
    cout<<"        标志        始址        长度"<<endl;
    while(nn)
    {
        printf("%10ld %12ld %12ld\n",nn->state,nn->start,nn->length);
        nn=nn->next;
    }
    nn=NULL;
    cout<<"end"<<endl;
    return 0;
}

int sortlist(int i)//排序空闲区表，1最先适应算法按照起始地址递增，2最佳适应算法按分区从小到大，3最坏适应算法按分区从大到小
{//链表所以选择排序
    if (flist==NULL||flist->next==NULL) return 0;//表不能为空
    freetable *change,*last;
    freetable *newhead,*newlast=NULL;
    newhead=(freetable  *)malloc(sizeof(freetable ));newhead->next=NULL;
    while(flist->next!=NULL)
    {
        change=flist;
        last=flist->next;
        if (last!=NULL)//说明至少有一个,last->next才有意义
        {
            while(last->next!=NULL)
            {
                if (i==1)
                {
                    if (change->next->start < last->next->start) change=last;
                }else if (i==2)
                {
                    if (change->next->length < last->next->length) change=last;
                }else if (i==3)
                {
                    if (change->next->length > last->next->length) change=last;
                }
                last=last->next;
            }
        }
        last=change->next;
        change->next=last->next;
        last->next=newhead->next;
        newhead->next=last;
    }
    free(flist);
    flist=newhead;
    newhead=newlast=last=change=NULL;
    return 0;
}

int menu()//菜单选择
{
    flist=(freetable *)malloc(sizeof(freetable)); flist->next=NULL;//哨兵节点
    blist=(freetable *)malloc(sizeof(freetable)); blist->next=NULL;
    int i=1,j=1;
    while(i)
    {
        system("reset");
        cout<<"-------------主菜单--------------"<<endl;
        cout<<"0退出程序"<<endl<<"1添加空闲区/已分配表"<<endl<<"2查看空闲区/已分配表"<<endl<<"3分配功能"<<endl<<"4回收功能"<<endl;
        cout<<"您的选择：";
        cin>>i;j=1;
        system("reset");
        if (i==0)
        {
            cout<<"谢谢使用"<<endl;
            break;
        }else if (i==1)
        {
            while(j)
            {
                cout<<"请选择添加"<<endl<<"0退出当前"<<endl<<"1空闲区"<<endl<<"2已分配表"<<endl;
                cout<<"您的选择：";
                cin>>j;
                system("reset");
                if (j==0) break;
                else if (j==1||j==2) {initializtion(j);showlist(j);}
                else cout<<"输入非法，请重新输入"<<endl;
            }
        }else if (i==2)
        {
            while(j)
            {
                cout<<"请选择查看"<<endl<<"0退出当前"<<endl<<"1空闲区"<<endl<<"2已分配表"<<endl;
                cout<<"您的选择：";
                cin>>j;
                system("reset");
                if (j==0) break;
                else if (j==1||j==2) showlist(j);
                else cout<<"输入非法，请重新输入"<<endl;
            }
        }else if (i==3)
        {
            long cnum,csize;
            while(j)
            {
                cout<<"请选择算法"<<endl<<"0退出当前"<<endl<<"1最先适应算法"<<endl<<"2最佳适应算法"<<endl<<"3最坏适应算法"<<endl;
                cout<<"您的选择：";
                cin>>j;
                system("reset");
                if (j==0) break;
                if (j!=1&&j!=2&&j!=3)
                {
                    cout<<"输入非法，请重新输入"<<endl;
                    continue;
                }
                showlist(1);showlist(2);
                cout<<"请输入需要分配的进程的进程号、需内存大小"<<endl;
                cin>>cnum>>csize;
                if (j==3) worstfit(cnum,csize);//最坏适应算法
                else firstbest(j,cnum,csize);//最先适应算法,最佳适应算法
            }
        }else if (i==4)
        {
            long cnum;
            while(j)
            {
                system("reset");
                cout<<"请输入需要回收的进程的进程号"<<endl;
                cin>>cnum;
                recover(cnum);
                cout<<"您的选择：0退出，1继续（不为0的数）";
                cin>>j;
            }
        }else cout<<"输入非法，请重新输入"<<endl;
    }
    return 0;
}

int firstbest(long j,long cnum,long csize)//j:1最先适应算法,2最佳适应算法
{
    sortlist(j);//j:1最先适应算法按照起始地址递增,2最佳适应算法按分区从小到大
    freetable *head=flist,*nn;
    while(head->next!=NULL)
    {
        if (head->next->length >= csize)
        {
            if (head->next->length==csize)
            {
                nn=head->next;
                nn->state=cnum;
                head->next=nn->next;
                nn->next=blist->next;
                blist->next=nn;
            }else
            {
                nn=(freetable  *)malloc(sizeof(freetable ));
                nn->start=head->next->start;
                nn->state=cnum;
                nn->length=csize;
                head->next->length-=csize;
                head->next->start+=csize;
                nn->next=blist->next;
                blist->next=nn;
            }
            csize=-1;
            break;
        }
        head=head->next;
    }
    if (csize==-1) cout<<"分配成功"<<endl;
    else {cout<<"分配失败"<<endl;return 0;}
    showlist(1);showlist(2);
    return 0;
}

int worstfit(long cnum,long csize)//最坏适应算法
{
    sortlist(3);//3最坏适应算法按分区从大到小
    freetable *nn;
    if (flist->next!=NULL && flist->next->length >=csize)
    {
        if (flist->next->length==csize)
        {
            nn=flist->next;
            nn->state=cnum;
            flist->next=nn->next;
            nn->next=blist->next;
            blist->next=nn;
        }else
        {
            nn=(freetable  *)malloc(sizeof(freetable ));
            nn->start=flist->next->start;
            nn->state=cnum;
            nn->length=csize;
            flist->next->length-=csize;
            flist->next->start+=csize;
            nn->next=blist->next;
            blist->next=nn;
        }
        cout<<"分配成功"<<endl;
        showlist(1);showlist(2);
    }else {cout<<"分配失败"<<endl;return 0;}
    return 0;
}

int recover(long cnum)//回收功能
{
    freetable *busyhead=blist,*freehead=flist,*nn;
    if (busyhead->next==NULL)
    {
        cout<<"无需回收资源"<<endl;
        return 0;
    }
    while(busyhead->next!=NULL)
    {
        if (busyhead->next->state==cnum)//全添加到freelist
        {
            nn=busyhead->next;
            busyhead->next=nn->next;
            nn->next=freehead->next;
            freehead->next=nn;
        }else busyhead=busyhead->next;
    }
    sortlist(1);//1按照起始地址递增空闲区
    freehead=flist;
    freehead=freehead->next;
    if (freehead==NULL)
    {
        cout<<"无空闲资源"<<endl;
        return 0;
    }
    while(freehead->next!=NULL)//至少有下一个
    {
        if ((freehead->length+freehead->start) == freehead->next->start)//合并
        {
            nn=freehead->next;
            freehead->length=freehead->length+nn->length;
            freehead->next=nn->next;
            nn->next=NULL;
        }else freehead=freehead->next;
    }
    showlist(1);showlist(2);
    return 0;
}

int main()
{
    menu();
    return 0;
} 

动态分区算法C加强

#include<stdio.h>
#include<stdlib.h>
struct nodespace{
    int teskid;   // 任务号
    int begin;    // 开始地址
    int size;     // 大小
    int status;   // 状态 0代表占用，1代表空闲
    struct nodespace *next;  // 后指针
};

void initNode(struct nodespace *p){
    if(p == NULL){  //如果为空则新创建一个
        p = (struct nodespace*)malloc(sizeof(struct nodespace));
    }
    p->teskid = -1;
    p->begin = 0;
    p->size = 640;
    p->status = 1;
    p->next =NULL;
}

/*
*  首次适应算法
*/
void myMalloc1(int teskid,int size,struct nodespace *node){
    while(node != NULL){
        if(node->status == 1){  //空闲的空间
            if(node->size > size){  //当需求小于剩余空间充足的情况
                //分配后剩余的空间
                struct nodespace *p = (struct nodespace*)malloc(sizeof(struct nodespace));
                p->begin = node->begin + size;
                p->size = node->size - size;
                p->status = 1;
                p->teskid = -1;
                //分配的空间
                node->teskid = teskid;
                node->size = size;
                node->status = 0;
                //改变节点的连接
                p->next = node->next;
                node->next = p;
                break;
            }else if(node->size == size){ //需求空间和空闲空间大小相等时
                node->teskid = teskid;
                node->size = size;
                node->status = 0;
                break;
            }
        }
        if(node->next == NULL){
            printf("分配失败，没有足够的空间！\n");
            break;
        }
        node = node->next;
    }
} 

/*
* 最佳适应算法
*/
void myMalloc2(int teskid,int size,struct nodespace *node){
    //最佳块指针
    struct nodespace *q = NULL;
    //首先找到第一个满足条件的空闲块
    while(node != NULL){
        if(node->status == 1 && node->size >= size){
            q = node;
            break;
        }
        //如果下一个为空则说明没有空闲区可以分配
        if(node->next == NULL){
            printf("分配失败，没有足够的空间！\n");
            break;
        } else{
            node = node->next;
        }

    }
    //遍历寻找最佳的空闲块
    while(node != NULL){
        if(node->status == 1 && node->size >= size && node->size < q->size){  //空闲的空间
            q = node;
        }
        node = node->next;
    }
    if(q->size > size){             //最佳空闲块的大小大于需求大小
        //分配后剩余的空间
        struct nodespace *p = (struct nodespace*)malloc(sizeof(struct nodespace));
        p->begin = q->begin + size;
        p->size = q->size - size;
        p->status = 1;
        p->teskid = -1;
        //分配的空间
        q->teskid = teskid;
        q->size = size;
        q->status = 0;
        //改变节点的连接
        p->next = q->next;
        q->next = p;
    }else if(q->size == size){      //最佳空闲块空间大小和需求相等
        q->teskid = teskid;
        q->size = size;
        q->status = 0;
    }
}

void myFree(int teskid,struct nodespace *node){
    if(node->next == NULL && node->teskid == -1){
        printf("还没有分配任何任务！\n");
    }

    while(node != NULL){
        if(node->status == 1 && node->next->status ==0 && node->next->teskid == teskid){  //释放空间的上一块空间空闲时
            node->size = node->size + node->next->size;
            struct nodespace *q = node->next;
            node->next = node->next->next;
            free(q);
            if(node->next->status == 1){ //下一个空间是空闲空间时
                node->size = node->size + node->next->size;
                struct nodespace *q = node->next;
                node->next = node->next->next;
                free(q);
            }
            break;
        }else if(node->status == 0 && node->teskid == teskid){  //释放空间和空闲空间不连续时
            node->status = 1;
            node->teskid = -1;
            if(node->next != NULL && node->next->status == 1){ //下一个空间是空闲空间时
                node->size = node->size + node->next->size;
                struct nodespace *q = node->next;
                node->next = node->next->next;
                free(q);
            }
            break;
        }else if(node->next == NULL){  //任务id不匹配时
            printf("没有此任务！\n");
            break;
        }
        node = node->next;
    }

}

void printNode(struct nodespace *node){
    printf("                        内存情况                        \n");
    printf(" -------------------------------------------------------\n");
    printf("| 起始地址\t结束地址\t大小\t状态\t任务id\t|\n");
    while(node != NULL){
        if(node->status==1){
            printf("| %d\t\t%d\t\t%dKB\tfree\t 无\t|\n", node->begin + 1, node->begin+node->size, node->size);
        }else{
            printf("| %d\t\t%d\t\t%dKB\tbusy\t %d\t|\n", node->begin + 1, node->begin+node->size, node->size, node->teskid);
        }
        node = node->next;
    }
    printf(" -------------------------------------------------------\n");
}

void destory(struct nodespace *node){
    struct nodespace *q = node;
    while(node != NULL){
        node = node->next;
        free(q);
        q = node;
    }
}

void menu(){
    printf("1.分配内存\n");
    printf("2.回收内存\n");
    printf("3.查看内存情况\n");
    printf("4.退出\n");
    printf("请输入选项:");
}

int main(){
    // node为整个空间
    struct nodespace *init = (struct nodespace*)malloc(sizeof(struct nodespace));
    struct nodespace *node = NULL;
    initNode(init);         //初始化主链
    node = init;            //指向链表头
    int option;
    int teskid;
    int size;
    while(1){
        printf("请选择模式：\n 1.演示模式\n 2.自由模式\n 3.退出\n");
        scanf("%d",&option);
        if(option == 1){    //演示模式
            while(1){       //循环选择实现的算法
                printf("请选择算法：\n 1.首次适应算法\n 2.最佳适应算法\n 3.退出\n");
                scanf("%d",&option);
                if(option == 1){            //首次适应算法
                    printf("作业1 申请130 KB\n");
                    myMalloc1(1,130,node);      //作业1 申请130 KB
                    printNode(node);
                    printf("作业2 申请60 KB\n");
                    myMalloc1(2,60,node);       //作业2 申请60 KB
                    printNode(node);
                    printf("作业3 申请100 KB\n");
                    myMalloc1(3,100,node);      //作业3 申请100 KB
                    printNode(node);
                    printf("作业2 释放60 KB\n");
                    myFree(2,node);         //作业2 释放60 KB
                    printNode(node);
                    printf("作业4 申请200 KB\n");
                    myMalloc1(4,200,node);      //作业4 申请200 KB
                    printNode(node);
                    printf("作业3 释放100 KB\n");
                    myFree(3,node);         //作业3 释放100 KB
                    printNode(node);
                    printf("作业1 释放130 KB\n");
                    myFree(1,node);         //作业1 释放130 KB
                    printNode(node);
                    printf("作业5 申请140 KB\n");
                    myMalloc1(5,140,node);      //作业5 申请140 KB
                    printNode(node);
                    printf("作业6 申请60 KB\n");
                    myMalloc1(6,60,node);       //作业6 申请60 KB
                    printNode(node);
                    printf("作业7 申请50 KB\n");
                    myMalloc1(7,50,node);       //作业7 申请50 KB
                    printNode(node);
                    printf("作业6 释放60 KB\n");
                    myFree(6,node);         //作业6 释放60 KB
                    printNode(node);
                    destory(node);  //销毁链表
                    initNode(init); //重新初始化
                    node = init;    //重新指向开头
                }else if(option == 2){      //最佳适应算法
                    printf("作业1 申请130 KB\n");
                    myMalloc2(1,130,node);      //作业1 申请130 KB
                    printNode(node);
                    printf("作业2 申请60 KB\n");
                    myMalloc2(2,60,node);       //作业2 申请60 KB
                    printNode(node);
                    printf("作业3 申请100 KB\n");
                    myMalloc2(3,100,node);      //作业3 申请100 KB
                    printNode(node);
                    printf("作业2 释放60 KB\n");
                    myFree(2,node);         //作业2 释放60 KB
                    printNode(node);
                    printf("作业4 申请200 KB\n");
                    myMalloc2(4,200,node);      //作业4 申请200 KB
                    printNode(node);
                    printf("作业3 释放100 KB\n");
                    myFree(3,node);         //作业3 释放100 KB
                    printNode(node);
                    printf("作业1 释放130 KB\n");
                    myFree(1,node);         //作业1 释放130 KB
                    printNode(node);
                    printf("作业5 申请140 KB\n");
                    myMalloc2(5,140,node);      //作业5 申请140 KB
                    printNode(node);
                    printf("作业6 申请60 KB\n");
                    myMalloc2(6,60,node);       //作业6 申请60 KB
                    printNode(node);
                    printf("作业7 申请50 KB\n");
                    myMalloc2(7,50,node);       //作业7 申请50 KB
                    printNode(node);
                    printf("作业6 释放60 KB\n");
                    myFree(6,node);         //作业6 释放60 KB
                    printNode(node);
                    destory(node);  //销毁链表
                    initNode(init); //重新初始化
                    node = init;    //重新指向开头
                }else if(option == 3){      //退出
                    break;
                }else{
                    printf("您的输入有误，请重新输入！\n");
                }
            }
        }else if(option == 2){  //自由模式
            while(1){       //循环选择使用的算法
                printf("请选择算法：\n 1.首次适应算法\n 2.最佳适应算法\n 3.退出\n");
                scanf("%d",&option);
                int n = option;     //标记选择的算法，n == 1 表示首次适应算法, n == 2表示最佳适应算法
                if(option != 3){
                    while(1){
                        menu();     //打印想要进行的操作
                        scanf("%d",&option);
                        if(option == 1 && n == 1){          //首次适应
                            printf("请输入任务id以及申请的空间大小:\n");
                            scanf("%d%d",&teskid,&size);
                            myMalloc1(teskid,size,node);
                            printNode(node);
                        }else if(option == 1 && n == 2){    //最佳适应
                            printf("请输入任务id以及申请的空间大小:\n");
                            scanf("%d%d",&teskid,&size);
                            myMalloc2(teskid,size,node);
                            printNode(node);
                        }else if(option == 2){
                            printf("请输入任务id:\n");
                            scanf("%d",&teskid);
                            myFree(teskid,node);
                            printNode(node);
                        }else if(option == 3){
                            printNode(node);
                        }else if(option == 4){
                            destory(node);  //销毁链表
                            initNode(init); //重新初始化
                            node = init;    //重新指向开头
                            break;
                        }else{
                            printf("您的输入有误，请重新输入！\n");
                            continue;
                        }
                    }
                }else if(option == 3){
                    destory(node);  //销毁链表
                    initNode(init); //重新初始化
                    node = init;    //重新指向开头
                    break;
                }
                else{
                    printf("您的输入有误，请重新输入！\n");
                }
            } 

        }else if(option == 3){  //退出
            destory(node);
            return 0;
        }else {
            printf("您的输入有误，请重新输入！\n");
            continue;
        }
    }
    return 0;
}

原文地址：https://www.cnblogs.com/lohh/p/11969899.html