#include
#include
struct?Memory
{
	int?startaddre;//開始地址?
	int?endaddre;//結束地址?
	int?id;//標記進程號?
	int?size;//分區大小?
	int?state;//是否被占進程用標記?0?表示未被占用，1?表示被占用
	struct?Memory?*?next;
};
typedef?struct?Memory?memory;
typedef?struct?node
{
	int?no;//序號?
	int?id;//進程號?
	int?operation;//執行操作?
	int?volume;//進程所需內存內存?
	
}PCB;?
PCB?pcb[100];//輸入進程數組
int?p_ptr=0;//輸入進程大小
PCB?pc;?

void?FF（memory?*p）;//首次適應?
void?BF（memory?*pmemory?*head）;//最佳適應?
void?WF（memory?*pmemory?*head）;//最壞適應?

void?FFallocate（PCB?pcmemory?*p）?;//最先適應分配分區算法?
void?BFallocate（PCB?pcmemory?*pmemory?*head）?;//最佳適應
void?WFallocate（PCB?pcmemory?*pmemory?*head）?;//最壞適應?
void?free_（PCB?pcmemory?*p）;//釋放分區算法?
void?print（PCB?pcmemory?*p）?;//輸出分區鏈表狀態函數?

main（）
{
	?
	int?num;//算法類型
	int?len;//開始可分配內存空間?
	memory?*head*p;
	head=（memory?*）malloc（sizeof（memory））;
	head->next=NULL;
	scanf（“%d“&num）;
	scanf（“%d“&head->size）;
	head->startaddre=0;
	head->state=0;
	head->endaddre=head->size+head->startaddre-1;
	p=head;
	while（scanf（“%d/%d/%d/%d“&pcb[p_ptr].no
	&pcb[p_ptr].id&pcb[p_ptr].operation&pcb[p_ptr].volume）==4）?
	{
		p_ptr++;
	}
	switch?（num）
	{
		case?1:
			FF（p）;//先適應算法?
			break;
		case?2:
			BF（phead）;//最佳適應算法?
			break;
		case?3:
			WF（phead）;//最壞適應算法?
			break;
		defaul?:
			break;
	}			
}
void?FFallocate（PCB?pcmemory?*p）	//首適應分配內存算法?
{?
	while（p!=NULL）	//從鏈表首指針一直找到尾指針?
	{
		if（（pc.volumesize）&&p->state==0）
		//進程未分配且能在分區分配這個進程?
		//將有剩余內存空間?相當于在后面插入節點?
		{
			p->id=pc.id;//分區記錄下進程號?
			p->state=1;//標記被占用?
			p->endaddre=p->startaddre+pc.volume-1;
			memory?*add;//增加一個鏈表
			add=（memory?*）malloc（sizeof（memory））;
			//在p后面插入add鏈表?
			add->startaddre=p->endaddre+1;
			
			add->size?=p->size-pc.volume;
			add->endaddre=add->startaddre+add->size-1;
			add->state=0;
			
			add->next=p->next?;//插入?
			p->next=add;	???//操作?
			p->size=pc.volume;
			break;
		}
		//進程未分配且能在分區分配這個進程?
		//沒有剩余內存空間?只是占用標記位改變?
		else?if（pc.volume==p->size&&p->state==0）?
		{
			p->id=pc.id;//分區記錄下進程號?
			p->state=1;//標記被占用
			break;?
		}
		p=p->next;
	}
}

void?BFallocate（PCB?pcmemory?*pmemory?*head）
{??
	int?sub=-1;//分區鏈表內存與將要分配進程內存之差?
	int?minsub=-1;//分區鏈表內存與將要分配進程內存之差最小值。
	
	//初始化為-1;
	
	int?flag1=0;//標記是否是第一次適應?
	int?location=0;?//記錄最小之差的鏈表位置?
	int?len=0;//記錄鏈表位置?
	while（p!=NULL）
	{
		if（p->state==0&&（p->size-pc.volume）>=0）?//鏈表區空閑且內存比進程所需內存大則可以存進程?
		{
			//不能把sub在if外面賦值，否則sub將一直>=0?
			sub=p->size-pc.volume;//鏈表區與進程所需內存之差?
			if（flag1==0）//第一個能存進程的鏈表?
			{
				minsub=sub;//此時內存之差?
				location=len;?//記錄鏈表位置?
			}
			else?//從多個鏈表找出一個內存之差最小的
			{	
				if（sub				{
					minsub=sub;
					location=len;//記錄其下標
				}
			}
			flag1++;
		}
		len++;//表示鏈表位置后移?
		p=p->next;
	}
	
	if（minsub>=0）	/*/能存入進程minsub才>=0?/*/
	
	
	{	
		int?i;
		p=head;		
		//之前p指向鏈表尾指針，現在應該指向頭指針?
		//從頭開始尋找標志位?滿足則?p指向它?
		for（i=0;i		{