动态分区代码

管道程序

#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
", 12);//向管道写端写入数据“hello world
”
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
", 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
", 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结束
");
	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("内存分配失败
");
			}
			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("操作结束
");
			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
",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("分配失败，没有足够的空间！
");
			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("分配失败，没有足够的空间！
");
			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("还没有分配任何任务！
");
	}
	
	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("没有此任务！
");
			break;
		}
		node = node->next;
	}
	
	 
}
 
void printNode(struct nodespace *node){
	printf("                        内存情况                        
"); 
	printf(" -------------------------------------------------------
");
	printf("| 起始地址	结束地址	大小	状态	任务id	|
");
	while(node != NULL){
		if(node->status==1){
			printf("| %d		%d		%dKB	free	 无	|
", node->begin + 1, node->begin+node->size, node->size);
		}else{
			printf("| %d		%d		%dKB	busy	 %d	|
", node->begin + 1, node->begin+node->size, node->size, node->teskid);
		}
		node = node->next;
	}
	printf(" -------------------------------------------------------
");
}
 
void destory(struct nodespace *node){
	struct nodespace *q = node;
	while(node != NULL){
		node = node->next;
		free(q);
		q = node;
	}
}
 
void menu(){
	printf("1.分配内存
");
	printf("2.回收内存
");
	printf("3.查看内存情况
");
	printf("4.退出
");
	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("请选择模式：
 1.演示模式
 2.自由模式
 3.退出
");
		scanf("%d",&option);
		if(option == 1){	//演示模式 
			while(1){		//循环选择实现的算法 
				printf("请选择算法：
 1.首次适应算法
 2.最佳适应算法
 3.退出
");
				scanf("%d",&option);
				if(option == 1){			//首次适应算法 
					printf("作业1 申请130 KB
");
					myMalloc1(1,130,node);		//作业1 申请130 KB
					printNode(node);
					printf("作业2 申请60 KB
");
					myMalloc1(2,60,node);		//作业2 申请60 KB
					printNode(node);
					printf("作业3 申请100 KB
");
					myMalloc1(3,100,node);		//作业3 申请100 KB
					printNode(node);
					printf("作业2 释放60 KB
");
					myFree(2,node);			//作业2 释放60 KB
					printNode(node);
					printf("作业4 申请200 KB
");
					myMalloc1(4,200,node);		//作业4 申请200 KB
					printNode(node);
					printf("作业3 释放100 KB
");
					myFree(3,node);			//作业3 释放100 KB
					printNode(node);
					printf("作业1 释放130 KB
");
					myFree(1,node);			//作业1 释放130 KB
					printNode(node);
					printf("作业5 申请140 KB
");
					myMalloc1(5,140,node);		//作业5 申请140 KB
					printNode(node);
					printf("作业6 申请60 KB
");
					myMalloc1(6,60,node);		//作业6 申请60 KB
					printNode(node);
					printf("作业7 申请50 KB
");
					myMalloc1(7,50,node);		//作业7 申请50 KB
					printNode(node);
					printf("作业6 释放60 KB
");
					myFree(6,node);			//作业6 释放60 KB
					printNode(node);
					destory(node);	//销毁链表
					initNode(init);	//重新初始化 
					node = init;	//重新指向开头 
				}else if(option == 2){		//最佳适应算法 
					printf("作业1 申请130 KB
");
					myMalloc2(1,130,node);		//作业1 申请130 KB
					printNode(node);
					printf("作业2 申请60 KB
");
					myMalloc2(2,60,node);		//作业2 申请60 KB
					printNode(node);
					printf("作业3 申请100 KB
");
					myMalloc2(3,100,node);		//作业3 申请100 KB
					printNode(node);
					printf("作业2 释放60 KB
");
					myFree(2,node);			//作业2 释放60 KB
					printNode(node);
					printf("作业4 申请200 KB
");
					myMalloc2(4,200,node);		//作业4 申请200 KB
					printNode(node);
					printf("作业3 释放100 KB
");
					myFree(3,node);			//作业3 释放100 KB
					printNode(node);
					printf("作业1 释放130 KB
");
					myFree(1,node);			//作业1 释放130 KB
					printNode(node);
					printf("作业5 申请140 KB
");
					myMalloc2(5,140,node);		//作业5 申请140 KB
					printNode(node);
					printf("作业6 申请60 KB
");
					myMalloc2(6,60,node);		//作业6 申请60 KB
					printNode(node);
					printf("作业7 申请50 KB
");
					myMalloc2(7,50,node);		//作业7 申请50 KB
					printNode(node);
					printf("作业6 释放60 KB
");
					myFree(6,node);			//作业6 释放60 KB
					printNode(node);
					destory(node);	//销毁链表
					initNode(init);	//重新初始化 
					node = init;	//重新指向开头 
				}else if(option == 3){		//退出
					break;
				}else{
					printf("您的输入有误，请重新输入！
"); 
				}
			} 	
		}else if(option == 2){	//自由模式 
			while(1){		//循环选择使用的算法 
				printf("请选择算法：
 1.首次适应算法
 2.最佳适应算法
 3.退出
");
				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以及申请的空间大小:
");
							scanf("%d%d",&teskid,&size);
							myMalloc1(teskid,size,node);
							printNode(node);
						}else if(option == 1 && n == 2){	//最佳适应 
							printf("请输入任务id以及申请的空间大小:
");
							scanf("%d%d",&teskid,&size);
							myMalloc2(teskid,size,node);
							printNode(node);
						}else if(option == 2){
							printf("请输入任务id:
");
							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("您的输入有误，请重新输入！
");
							continue;
						}
					}
				}else if(option == 3){
					destory(node);	//销毁链表
					initNode(init);	//重新初始化 
					node = init;	//重新指向开头 
					break;
				}
				else{
					printf("您的输入有误，请重新输入！
");
				}
			} 
				
		}else if(option == 3){	//退出  
			destory(node);
			return 0;
		}else {
			printf("您的输入有误，请重新输入！
");
			continue;
		}
	}
	return 0;
}