空闲分区链源代码

#include
using namespace std;

int position_now=0;
int scale_now=640;

typedef struct Work_node
{
	int work;
	int position;
	int scale;
	struct Work_node *pNext;
	
}WORK_NODE*PWORK_NODE;// WORK_NODE等价于struct Work_node；PWORK_NODE等价于struct Work_node*；数据类型

PWORK_NODE work_first=（PWORK_NODE）malloc（sizeof（WORK_NODE））;
PWORK_NODE work_tail=work_first;
int work_count=0; 


void Insert_List_work（int workint scale）
{
	
	PWORK_NODE m=（PWORK_NODE）malloc（sizeof（WORK_NODE））;
	
	m->work=work;
	m->scale=scale;
	m->position=position_now;
	m->pNext=NULL;
	

if（work_count==0）
		work_first=work_tail=m;
	
	else
	{
		work_tail->pNext=m;
		work_tail=m;
	}
	
	
	work_count++;

	
}

void Delete_List_work（int work）
{
	PWORK_NODE p=work_first;
	PWORK_NODE m=work_first;
	while（p->work!=work）
	{
		m=p;
		p=p->pNext;		
	}
	position_now=p->position;
	scale_now=p->scale;	
	if（p==work_first）
	{
		work_first=p->pNext;
	}
	else
	{
		m->pNext=p->pNext;
		
	}

	work_count--;


}

typedef struct Space_node
{
	int position;
	int scale;
	struct Space_node *pNext;
	
}SPACE_NODE*PSPACE_NODE;// SPACE_NODE等价于struct Space_node；*PSPACE_NODE等价于struct Space_node*；数据类型

PSPACE_NODE space_first=（PSPACE_NODE）malloc（sizeof（SPACE_NODE））;
int space_count=1;

void Allocate_List（int scale）
{

	if（scale_now==640）
	{
		PSPACE_NODE m0=（PSPACE_NODE）malloc（sizeof（SPACE_NODE））;
		m0->position=0;
		m0->scale=640;
		m0->pNext=NULL;
		space_first=m0;
		
	}
	
	PSPACE_NODE p=space_first;
	if（p->scale		p=p->pNext;

	p->position+=scale;
	p->scale-=scale;
	position_now=p->position;
	scale_now=p->scale;	 
	
	

}
////////////////首次适应算法///////////////////////
/*
void Free_List（）
{
	
	PSPACE_NODE m=（PSPACE_NODE）malloc（sizeof（Space_node））;
	m->position=position_now;
	m->scale=scale_now;

	PSPACE_NODE p=space_first;
	PSPACE_NODE n=space_first;

	while（p->position	{
		n=p;
		p=p->pNext;
		
	}	
	if（p==space_first）
	{
		if（m->position+m->scale==p->position）
		{
			p->position-=m->scale;
			p->scale+=m->scale;
		}
		else
		{
			space_first=m;
			m->pNext=p;
			space_count++;
		}
	}
	
	else if（n->position+n->scale==m->position）
	{
		n->scale+=m->scale;
		free（m）;
	}
	else if（n==space_first）
	{
		space_first=m;
		m->pNext=p;
		space_count++;
	}
	else 
	{
		m->pNext=p->pNext;
		n->pNext=m;
		space_count++;
	}		
}*/
/////////////////////////////////////////////

////////////////////最佳适应算法/////////////////////////
void Free_List（）
{
	
	PSPACE_NODE m=（PSPACE_NODE）malloc（sizeof（Space_node））;
	m->position=position_now;
	m->scale=scale_now;


	PSPACE_NODE t=space_first;
	int flag=