实现动态分区分配模拟程序

实验内容： 编写一个动态分区分配算法模拟程序，加深对动态分区存储管理方式及其实现过程的理解。 要求： 1.空闲分区通过空闲区链进行管理，在内存分配时，优先考虑低地址部分的空闲区。 2.分别采用首次适应算法、最佳适应算法和最坏适应算法模拟内存空间的动态分配与回收，每次分配和回收后显示出空闲区链的详细情况（说明：在申请不成功时，需要打印当前内存的占用情况信息）。 3.进程对内存空间的申请和释放可由用户自定义输入。 4.参考请求序列如下： (1) 初始状态下可用内存空间为640KB； (2) 进程1申请130KB； (3) 进程2申请60KB； (4) 进程3申请100KB； (5) 进程2释放60KB； (6) 进程4申请200KB； (7) 进程3释放100KB； (8) 进程1释放130KB； (9) 进程5申请140KB； (10) 进程6申请60KB； (11) 进程7申请50KB； (12) 进程6释放60KB。 测试用例格式如下： 输入： 动态分区分配算法选择 可用内存空间容量 序号/进程号/申请或释放操作/申请或释放的容量 其中： (1) 动态分区分配算法：1----首次适应，2----最佳适应，3----最坏适应 (2) 申请或释放操作： 1----申请操作，2----释放操作 输出： 序号/内存空间状态1/内存空间状态2...... 内存空间状态表示分为两种情况： (1) 内存空间被占用： 内存空间起始地址-内存空间结束地址.1.占用的进程号 (2) 内存空间空闲 内存空间起始地址-内存空间结束地址.0

#include
#include
struct Memory
{
	int startaddre;//开始地址 
	int endaddre;//结束地址 
	int id;//标记进程号 
	int size;//分区大小 
	int state;//是否被占进程用标记 0 表示未被占用，1 表示被占用
	struct Memory * next;
};
typedef struct Memory memory;
typedef struct node
{
	int no;//序号 
	int id;//进程号 
	int operation;//执行操作 
	int volume;//进程所需内存内存 
	
}PCB; 
PCB pcb[100];//输入进程数组
int p_ptr=0;//输入进程大小
PCB pc; 

void FF（memory *p）;//首次适应 
void BF（memory *pmemory *head）;//最佳适应 
void WF（memory *pmemory *head）;//最坏适应 

void FFallocate（PCB pcmemory *p） ;//最先适应分配分区算法 
void BFallocate（PCB pcmemory *pmemory *head） ;//最佳适应
void WFallocate（PCB pcmemory *pmemory *head） ;//最坏适应 
void free_（PCB pcmemory *p）;//释放分区算法 
void print（PCB pcmemory *p） ;//输出分区链表状态函数 

main（）
{
	 
	int num;//算法类型
	int len;//开始可分配内存空间 
	memory *head*p;
	head=（memory *）malloc（sizeof（memory））;
	head->next=NULL;
	scanf（“%d“&num）;
	scanf（“%d“&head->size）;
	head->startaddre=0;
	head->state=0;
	head->endaddre=head->size+head->startaddre-1;
	p=head;
	while（scanf（“%d/%d/%d/%d“&pcb[p_ptr].no
	&pcb[p_ptr].id&pcb[p_ptr].operation&pcb[p_ptr].volume）==4） 
	{
		p_ptr++;
	}
	switch （num）
	{
		case 1:
			FF（p）;//先适应算法 
			break;
		case 2:
			BF（phead）;//最佳适应算法 
			break;
		case 3:
			WF（phead）;//最坏适应算法 
			break;
		defaul :
			break;
	}			
}
void FFallocate（PCB pcmemory *p）	//首适应分配内存算法 
{ 
	while（p!=NULL）	//从链表首指针一直找到尾指针 
	{
		if（（pc.volumesize）&&p->state==0）
		//进程未分配且能在分区分配这个进程 
		//将有剩余内存空间 相当于在后面插入节点 
		{
			p->id=pc.id;//分区记录下进程号 
			p->state=1;//标记被占用 
			p->endaddre=p->startaddre+pc.volume-1;
			memory *add;//增加一个链表
			add=（memory *）malloc（sizeof（memory））;
			//在p后面插入add链表 
			add->startaddre=p->endaddre+1;
			
			add->size =p->size-pc.volume;
			add->endaddre=add->startaddre+add->size-1;
			add->state=0;
			
			add->next=p->next ;//插入 
			p->next=add;	   //操作 
			p->size=pc.volume;
			break;
		}
		//进程未分配且能在分区分配这个进程 
		//没有剩余内存空间 只是占用标记位改变 
		else if（pc.volume==p->size&&p->state==0） 
		{
			p->id=pc.id;//分区记录下进程号 
			p->state=1;//标记被占用
			break; 
		}
		p=p->next;
	}
}

void BFallocate（PCB pcmemory *pmemory *head）
{  
	int sub=-1;//分区链表内存与将要分配进程内存之差 
	int minsub=-1;//分区链表内存与将要分配进程内存之差最小值。
	
	//初始化为-1;
	
	int flag1=0;//标记是否是第一次适应 
	int location=0; //记录最小之差的链表位置 
	int len=0;//记录链表位置 
	while（p!=NULL）
	{
		if（p->state==0&&（p->size-pc.volume）>=0） //链表区空闲且内存比进程所需内存大则可以存进程 
		{
			//不能把sub在if外面赋值，否则sub将一直>=0 
			sub=p->size-pc.volume;//链表区与进程所需内存之差 
			if（flag1==0）//第一个能存进程的链表 
			{
				minsub=sub;//此时内存之差 
				location=len; //记录链表位置 
			}
			else //从多个链表找出一个内存之差最小的
			{	
				if（sub				{
					minsub=sub;
					location=len;//记录其下标
				}
			}
			flag1++;
		}
		len++;//表示链表位置后移 
		p=p->next;
	}
	
	if（minsub>=0）	/*/能存入进程minsub才>=0 /*/
	
	
	{	
		int i;
		p=head;		
		//之前p指向链表尾指针，现在应该指向头指针 
		//从头开始寻找标志位 满足则 p指向它 
		for（i=0;i		{