内存分配-最佳适应和首次适应

操作系统实验课二
题目：
因为上次实验没有用链表，这次实验就做得超慢，唉，主要还是菜。
本次实验踩到的坑（debug了好久呜呜呜）：我先改变了p->next的指向的值，然后free（p->next），啊所以就找了好久的问题，其实都好基础，不应该错的。还有就是不要随便定义变量，不然都不知道在哪里改了这个变量的值。

然后就是代码
这个是定义的内存块

struct memory_s 
{
	struct memory_s *pre;
	int begin;
	int end;
	bool state;
	struct memory_s *next;
	int num;
};

这个是分配内存的函数，就是这个地方有一点，如果最后那个内存块恰好够，就不用再加一个结点了，所以我用了一个判断。

void malloc_m(struct memory_s &pre,int require,int num)
{
	//分配一个tem存储剩下的空的空间；
	if(require<pre.end-pre.begin)
	{
		struct memory_s *tem1;
		tem1=(memory_s*)malloc(sizeof(memory_s));

		tem1->end=pre.end;
		pre.begin=pre.begin;
		pre.end=pre.begin+require;
		pre.state=true;
		pre.num=num;

		tem1->state=false;
		if(tem1->end==640)
		{
			tem1->next=NULL;
		}
		else{
			tem1->next=pre.next;
		}

		pre.next=tem1;
		tem1->begin=pre.end;
		tem1->pre=&pre;
		tem1->num=-1;
	}
	else//空间恰好够
	{
		pre.num=num;
		pre.state=true;
	}
}

这个是释放空间的代码

//一个进程释放空间
void free_m(struct memory_s &l,int num)
{
	//先检查前面是否是空
	//则应直接删除该结点并且修改指针
	memory_s *p=&l;
	while(1)
	{
        if(p->num==num)
		{
			if(p==&l)
			{
				//要合并p和p-next
				if(p->next->state==false)
				{
					memory_s *pt=p->next;
					p->next=p->next->next;
					p->end=p->next->end;
					p->state=false;
					p->next->next->pre=p;
					free(pt);
				}
				else
				{
					p->state=false;
					p->num=-1;
				}
			}
			else
			{
				if(p->pre->state==false)
				{
					if(p->next->state==false)
					{
					//删除这个和后一个
					//先修改指针
						memory_s *pt=p->next;
						p->pre->next=p->next->next;
						p->next->next->pre=p->pre;
						p->pre->end=p->next->end;
						p->pre->state=false;
						free(pt);
						free(p);
					}
					else
					{
						p->pre->end=p->end;
						p->pre->next=p->next;
						p->next->pre=p->pre;
						p->pre->state=false;
						free(p);
					}
				}
				else if(p->next->state==false)
				{
					memory_s *pt=p->next;
					p->next=p->next->next;
					p->end=p->next->end;
					p->next->next->pre=p;
					p->state=false;
					free(pt);
				}
				else
				{
					p->state=false;
					p->num=-1;
				}
			}
				break;
	    }
		p=p->next;
	}

}

然后是最佳适应的分配函数

void bf(struct memory_s &first,int require,int num)
{
	memory_s *p=&first;
	memory_s *pmax;
	int vol=640;
	while(p!=NULL)
	{
		if(p->state==false)
		{
			if(p->end-p->begin>=require)
			{
				if(vol>=p->end-p->begin)
				{
					pmax=p;
					vol=p->end-p->begin;
				}
			}
		}
		p=p->next;
	}
	malloc_m(*pmax,require,num);
}

然后是首次适应的函数

memory_s* check_ff(struct memory_s &first,int require,int num)
{
	memory_s *p=&first;
	while(p!=NULL)
	{
		if(p->state==false)
		{
			if(p->end-p->begin>=require)
			{
				malloc_m(*p,require,num);
				return p;
			}
		}
		p=p->next;
	}
}

显示函数
一定要和大佬学一下如何打印出漂亮的表格，每次我就只会cout。

void display(struct memory_s first)
{
	cout<<"当前正在使用内存的进程"<<endl;
	memory_s *p=&first;
	int i=1;
	while(p!=NULL)
	{
		if(p->state==false)
		{
			cout<<"第"<<i<<"结点是空闲，大小为"<<(p->end-p->begin)<<endl;
		}
		else
		{
			cout<<"当前是第"<<p->num<<"个作业在使用内存,大小为"<<(p->end-p->begin)<<endl;
		}
		p=p->next;
		i++;
	}
	cout<<endl;
}

最后没了。