动态分区分配-首次适应算法_动态分区分配首次适应算法-CSDN博客

本文详细介绍了首次适应算法的动态分区分配过程，并通过C语言实现了一个完整的内存管理程序，包括分配、回收作业和内存区域的管理。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

动态分区分配-首次适应算法

动态分区分配是根据进程的实际需要，动态的为之分配内存的空间。

首次适应算法，要求空闲分区链以地址递增的次序链接，在分配内存时，从链首开始顺序查找，直到找到一个大小能满足要求的空闲分区为止，然后再按照作业的大小，从该分区中划出一块内存空间分给请求者，余下的空闲分区仍停留在空闲链中。

当进程运行完毕释放内存，系统根据回收区的首址，从空闲区链表中找到相应的插入点，此时可能出现以下4种情况之一

1回收区与插入点的前一个空闲分区F1相邻接，此时将两个分区合并

2回收区与插入点的后一个空闲分区F2相邻接，此时将两个分区合并

3回收区与插入点的前，后两个空闲分区相邻接，此时将三个分区合并

4回收区既不与F1相邻接，又不与F2相邻接，此时应为回收区单独建立一个新表项

下面用C语言模拟首次适应算法

#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=1023;
	kongxian[0].length=1024;
}
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,k,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;
}

#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=1023;
	kongxian[0].length=1024;
}
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,k,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;
}