test c.cpp

实现动态分区管理模拟最先适应法和最佳适应法

	if(left==NULL&&right==NULL){insert();}
	else if(left!=NULL&&right==NULL)
	{
		left->fe_tail_address=a_sign->allo_tail_address;
		left->fe_size+=a_sign->allo_size;
		f_sign=left;
		sort_sign();
	}
	else if(left==NULL&&right!=NULL)
	{
		right->fe_head_address=a_sign->allo_head_address;
		right->fe_size+=a_sign->allo_size;
		f_sign=right;
		sort_sign();
	}
	else if(left!=NULL&&right!=NULL)
	{
		left->fe_tail_address=right->fe_tail_address;
		left->fe_size=a_sign->allo_size+left->fe_size+right->fe_size;
		if(right==fe_first){fe_first=right->next;
		fe_first->front=NULL;
		free(right);
		right=NULL;}
		else if(right==fe_tail)
		{
			right->front->next=NULL;
			fe_tail=right->front;
			free(right);
			right=NULL;
		}
		else{
			right->next->front=right->front;
			right->front->next=right->next;
			free(right);
			right=NULL;
		}
		f_sign=left;
        sort_sign();
	}

}
void insert()
{
	if(fe_first==NULL){
		fe_first=(fre *)malloc(sizeof(fre));
		fe_tail=fe_first;
		fe_first->fe_head_address=a_sign->allo_head_address;
		fe_first->fe_tail_address=a_sign->allo_tail_address;
		fe_first->fe_size=a_sign->allo_size;
		fe_first->front=fe_first->next=NULL;
		return;
	}
	fre * p=fe_first;
	fre * temp=NULL;
	while(p!=NULL)
	{
       if(p==fe_first&&(a_sign->allo_size<=p->fe_size))
	   {
		   temp=(fre *)malloc(sizeof(fre));
           temp->fe_head_address=a_sign->allo_head_address;
		   temp->fe_tail_address=a_sign->allo_tail_address;
		   temp->fe_size=a_sign->allo_size;
		   temp->front=NULL;
		   temp->next=fe_first;
		   fe_first->front=temp;
		   fe_first=temp;
		   break;
	   }
	   else if(p==fe_tail&&(a_sign->allo_size>p->fe_size))
	   {
		    temp=(fre *)malloc(sizeof(fre));
           temp->fe_head_address=a_sign->allo_head_address;
		   temp->fe_tail_address=a_sign->allo_tail_address;
		   temp->fe_size=a_sign->allo_size;
		   temp->front=fe_tail;
		   fe_tail->next=temp;
		   temp->next=NULL;
		   fe_tail=temp;
		   break;
	   }
	   else if((p->fe_size<a_sign->allo_size)&&(a_sign->allo_size<=p->next->fe_size))
	   {
          temp=(fre *)malloc(sizeof(fre));
           temp->fe_head_address=a_sign->allo_head_address;
		   temp->fe_tail_address=a_sign->allo_tail_address;
		   temp->fe_size=a_sign->allo_size;
		   p->next->front=temp;
		   temp->next=p->next;
		   p->next=temp;
		   temp->front=p;
		   break;
	   }
	   p=p->next;
	}
}
void sort_sign()
{
	fre * move=f_sign->next;
	while(move!=NULL)
	{
       if(f_sign==fe_first)
	   {
		   if(move==fe_tail&&(move->fe_size<f_sign->fe_size))
		   {
			   fe_first=f_sign->next;
			   f_sign->next=NULL;
			   move->next=f_sign;
			   f_sign->front=move;
			   fe_tail=f_sign;
			   break;
		   }else if((move->fe_size<f_sign->fe_size)&&(move->next->fe_size>=f_sign->fe_size))
		   {
               fe_first=f_sign->next;
			   move->next->front=f_sign;
			   f_sign->next=move->next;
			   move->next=f_sign;
			   f_sign->front=move;
			   break;
		   }
	   }
	   else if(move->fe_size<f_sign->fe_size)
	   {
		   f_sign->next->front=f_sign->front;
		   f_sign->front->next=f_sign->next;
          if(move==fe_tail)
		  {
             f_sign->next=NULL;
			 move->next=f_sign;
			 f_sign->front=move;
			 break;
		  }
		  if(move->next->fe_size>=f_sign->fe_size)
		  {
             move->next->front=f_sign;
			   f_sign->next=move->next;
			   move->next=f_sign;
			   f_sign->front=move;
			   break;
		  }

	   }
	   move=move->next;
	}
}
void bestfit_allocate(int r_size)
{
   if(f_sign==fe_first)
	{
		if(f_sign->fe_size==r_size)
		{fe_first=f_sign->next;
		temp_head=f_sign->fe_head_address;

		if(fe_first!=NULL)
		{fe_first->front=NULL;}
		}
		else{
			temp_head=f_sign->fe_head_address;
			f_sign->fe_head_address=f_sign->fe_head_address+r_size;
			f_sign->fe_size=f_sign->fe_size-r_size;
		}
	}
   else if(f_sign==fe_tail)
   {
        if(f_sign->fe_size==r_size)
		{
			fe_tail=f_sign->front;
			fe_tail->next=NULL;
		}
		else{
			if(f_sign->fe_size-r_size>=f_sign->front->fe_size)
			{temp_head=f_sign->fe_head_address;
			f_sign->fe_head_address=f_sign->fe_head_address+r_size;
			f_sign->fe_size=f_sign->fe_size-r_size;
             }
		
			else 
			{
				fe_tail=f_sign->front;
				fe_tail->next=NULL;
				fre * fp=fe_tail;
               temp_head=f_sign->fe_head_address;
			   f_sign->fe_head_address=f_sign->fe_head_address+r_size;
			  f_sign->fe_size=f_sign->fe_size-r_size;
				while(true)
				{
					if(f_sign->fe_size<fe_first->fe_size)
					{
                     f_sign->next=fe_first;
					 fe_first->front=f_sign;
					 fe_first=f_sign;
					 break;
					}
					if(fp->fe_size>f_sign->fe_size&&fp->front->fe_size<=f_sign->fe_size)
					{
                       fp->front->next=f_sign;
					   f_sign->front=fp->front;
					   f_sign->next=fp;
					   fp->front=f_sign;
					   break;
					}else{fp=fp->front;}

				}
			 }

		}

   }
   
}
void freerevise()
{
	allocated * dele=allo_first;
	if(a_sign==allo_first)
	{
		allo_first=a_sign->next;
		free(dele);
		dele=0;
		a_sign=0;
	}
	else{
	while(dele->next!=a_sign)dele=dele->next;
	dele->next=a_sign->next;
	free(a_sign);
	a_sign=0;
	}


}

int main(void)
{
	int in=0;
	while(true)
	{
		menu1();
        printf("please input number(1,2,3)...\n");
		scanf("%d",&in);
		switch(in)
		{
		case 1:system("cls");
			printf("you choose first fit algorithm!\n");
			   init();
               //bool tool=true;
			   while(true)
			   {
				   menu2();
				   int select;
				   scanf("%d",&select);
				   switch(select)
				   {
				   case 1:int id;int require_size;
					   printf("please input the ID of process and the size it demands\n");
					   scanf("%d%d",&id,&require_size);
					   if(check_if_free(require_size))
					   {
						   bestfit_allocate(require_size);addrevise(id,require_size);print();
					   }else{printf("we can not afford this process!\n");}
					   break;
				   case 2:int allocated_id;
					   printf("please input the id of process you want to free!\n");
					   scanf("%d",&allocated_id);
					   if(check_if_allocated(allocated_id))
					   {
						   firstfit_free();freerevise();print();
					   }else{printf("we can not find this process!\n");}
					   break;
				   case 3:system("cls");//clear();//tool=false;
					   break;
				   }
				   if(select==3)break;

			   }
			break;
		case 2:
               system("cls");
			printf("you choose best fit algorithm!\n");
			   init();
               //bool tool=true;
			   while(true)
			   {
				   menu2();
				   int select;
				   scanf("%d",&select);
				   switch(select)
				   {
				   case 1:int id;int require_size;
					   printf("please input the ID of process and the size it demands\n");
					   scanf("%d%d",&id,&require_size);
					   if(check_if_free(require_size))
					   {
						   bestfit_allocate(require_size);addrevise(id,require_size);print();
					   }else{printf("we can not afford this process!\n");}
					   break;
				   case 2:int allocated_id;
					   printf("please input the id of process you want to free!\n");
					   scanf("%d",&allocated_id);
					   if(check_if_allocated(allocated_id))
					   {
						   bestfit_free();freerevise();print();
					   }else{printf("we can not find this process!\n");}
					   break;
				   case 3:system("cls");//clear();
					   break;
				   }
				   if(select==3)break;

			   }

			break;
		case 3:printf("now you will leave..");
			   exit(1);break;
		}
		
	}
return 0;
}