c的循环首次适应算法

#include
#include 
#include“stdlib.h“

#define getpch（type） （type*）malloc（sizeof（type）） 
#define SysSize  1000;

struct LNode
{ 
	int size;
  	char *m_addr;
  	struct LNode *next;
  	struct LNode *front;
}*L; /*L为头指针*/

typedef struct LNode LN;

LN *find; //查找节点
int n //表示空闲分区数量
	fsize //空闲分区总量
	iniaddr; //初始地址位置
char *SysMemory;

void PrintList（） /*打印内存存储状况*/
{
	LN *p; int i;
	p=L;
	
	printf（“\n空闲空间状况（以%d为起始地址）\n“SysMemory）;
	printf（“\n空闲区号  长度  起始位置  相对位置\n“）;
	for（i=1;i<=n;i++）
	{
		printf（“%8d  %4d  %8d  %8d\n“ip->size p->m_addr （p->m_addr-SysMemory））;
		p=p->next;
	}
	printf（“\n“）;
}


void Initialize（）  /*生成空闲分区链*/
{
	int a = SysSize;
	L=getpch（LN）;  /*生成一个表头结点*/
	L->next=L;
	L->front=L;
	SysMemory = （char*） malloc（a）;
	L->m_addr=SysMemory;
	L->size = SysSize;
	fsize = L->size;
	iniaddr = （int）L->m_addr;
	n = 1;
	find = L;
	PrintList（）;
	printf（“\n空闲地址建立完成\n“）;
}// end of GetFree

void NF_Assign（unsigned size）/*循环首次适应算法的分配*/
{
	LN *p*t*s;
	
	p=find;

	if （fsize <= 0）
	{
		printf（“系统已无可用空间\n“）;
		return;
	}
	else if （size > fsize）
	{
		printf（“系统空间不足！分配不成功\n“）;
		return;
	}
	else if （size <= 0）
	{
		printf（“大小不正确！\n“）;
	}

	do
	{
		if（size > p->size）
		{
			p=p->next;
			if（p==find）
			{
				printf（“没有足够大的空闲区分配！分配不成功\n“）; break;			   
			}
		}
		else
		{
			p->size -= size;
			p->m_addr += size;
			fsize -= size;
			find=p->next;
			if（p->size==0）
			{
				t = getpch（LN）;
				t=p->next;
				t->front=p->front;
				（t->front）->next=t;
				n--;
				if （p == L） {L=t;}
				free（p）;
				find = t;
			}
			printf（“\n分配成功！\n“）;
			break;
		}
	} while （1）;
}// end of NF_Assign

void AdrSpace（unsigned size unsigned adr）
{
	LN *p*t;

	if（adr+SysMemory < L->m_addr）
	{
		t = getpch（LN）;
		
		t->size=L->size;
		t->m_addr = L->m_addr;
		t->next = L->next;
		L->m_addr = SysMemory + adr;
		L->size = size;
		L->next = t;
		t->front = L;
		for（p=L;p->next != L;p=p->next）{}
		p->next = L;
		L->front = p;
	}
	else
	{
		p=L;
		do
		{
			if （p->m_addr > SysMemory + adr） break;
			p = p->next;
		}
		while（p!=L）;
		t = getpch（LN）;
		t->size = size;
		t->next = p;
		t->front = p->front;
		p->front->next = t;
		t->m_addr = adr+SysMemory;
	}
}


void Recover（unsigned size unsigned adr）  /*回收*/
{
	LN *