动态分区分配是根据进程的实际需要，动态地址为之分配内存空间，在分配时按照一定的分配算法，从空闲分区表或空闲分区链中选出一分区分配给该作业

• 1.首次适应算法(FF):将所有空闲分区按照地址递增的次序链接，在申请内存分配时，从链首开始查找，将满足需求的第一个空闲分区分配给作业。

• 2.循环首次适应算法（NF）：将所有空闲分区按照地址递增的次序链接，在申请内存分配时，总是从上次找到的空闲分区的下一个空闲分区开始查找，将满足需求的第一个空闲分区分配给作业

• 3.最坏适应算法(WF)：将所有的空闲分区按照从大到小的顺序形成空闲分区链，在申请内存分配时，总是把满足需求的、最大的空闲分区分配给作业。

• 4.最佳适应算法(BF): 将所有空闲分区按照从小到大的顺序形成空闲分区链，在申请内存分配时，总是把满足需求的、最小的空闲分区分配给作业。

源码

#include <iostream>
#include <fstream>
#include <iomanip>
using namespace std;

#define MAXNUMBER 100
static int PartitionNum;  //内存中空闲分区的个数
static int ProcessNum; //需要分配的进程个数
static int FreePartition[MAXNUMBER];  //空闲分区对应的内存
static int ProcessNeed[MAXNUMBER];  //需要分配的进程大小

static int LeftFreePartition[MAXNUMBER];
static int LeftProcessNeed[MAXNUMBER];

static char ProcessName[MAXNUMBER];
static char NameProcessToPartition[MAXNUMBER][MAXNUMBER];

typedef struct
{
	int partitionSize;
	int id;
}sortNeed;

void readDataFunction();
void input();
void display();
void FirstFit();
void NextFit();
void BestFit();
void WorstFit();
void selectAlgorithm(int chooceAlgorithm);
void display();


void readDataFunction()
{
	cout<<"请输入空闲分区数"<<endl;
	cin >> PartitionNum;
		cout << "请输入空闲分区大小" << endl;
	for (int i = 0; i<PartitionNum; i++)
	{
		cin >> FreePartition[i];
	}
	cout<<"请输入进程个数"<<endl;
	cin >> ProcessNum;
		cout<<"请输入进程名称"<<endl;
	for (int i = 0; i<ProcessNum; i++)
	{
		cin >> ProcessName[i];
	}
		cout<<"请输入进程需要分配大小"<<endl;
	for (int i = 0; i<ProcessNum; i++)
	{
		cin >> ProcessNeed[i];
	}
}

void input()
{
	int chooseAlgorithm = 5;
	do
	{
	//readDataFunction();
	cout << "请选择实现的算法：" << endl;
	cout << "*****  1 - 首次适应算法     *****" << endl;
	cout << "*****  2 - 循环首次适应算法 *****" << endl;
	cout << "*****  3 - 最佳适应算法     *****" << endl;
	cout << "*****  4 - 最坏适应算法     *****" << endl;
	cout << "*****  0 - 结束             *****" << endl;
		cout << "chooseAlgorithm = ";
		cin >> chooseAlgorithm;
		selectAlgorithm(chooseAlgorithm);
	//display();
	} while (chooseAlgorithm);
}

void initial()
{
	readDataFunction();   //读取原始数据
	for (int i = 0; i<PartitionNum; i++)
	{
		LeftFreePartition[i] = FreePartition[i];
		for (int j = 0; j<ProcessNum; j++)
		{
			NameProcessToPartition[i][j] = NULL;
		}
	}
	for (int i = 0; i<ProcessNum; i++)
	{
		LeftProcessNeed[i] = ProcessNeed[i];
	}
}


void FirstFit()
{
	cout << "***********首次适应算法***********" << endl;
	initial();

	int i, j;
	for (i = 0; i<ProcessNum; i++)   //逐个遍历每个进程
	{
		for (j = 0; j<PartitionNum; j++)
		{
			if (LeftProcessNeed[i] <= LeftFreePartition[j] && LeftFreePartition != 0)  //当系统内存分区足够大的时候，即分配给进程资源
			{
				LeftFreePartition[j] -= LeftProcessNeed[i];   //扣除分配给进程的资源
				LeftProcessNeed[i] = 0;  //当且仅当系统内存分区足够时才执行，即当前进程大小置0

				NameProcessToPartition[i][j] = ProcessName[i];  //存储各个进程所在的分区位置

				break;   //!!!很重要，一个进程分区完后，应该立即break，进行下一个进程的判断
			}
		}
	}

	display();

}

void NextFit()
{
	cout << "***********循环首次适应算法***********" << endl;
	initial();
	int i, nextPoint = 0;
	bool isWhile;
	for (i = 0; i<ProcessNum; i++)
	{
		isWhile = true;
		while (isWhile)
		{
			if (LeftFreePartition[nextPoint] >= LeftProcessNeed[i])
			{
				LeftFreePartition[nextPoint] -= LeftProcessNeed[i];
				LeftProcessNeed[i] = 0;
				NameProcessToPartition[i][nextPoint] = ProcessName[i];
				nextPoint++;
				if (nextPoint > PartitionNum - 1)
				{
					nextPoint = 0;  //当j遍历到分区末尾的时候，返回首位置
				}
				isWhile = false;
			}
			else
				nextPoint++;
		}
	}
	display();
}

void BestFit()
{
	//思想：利用冒泡排序对分区大小进行排序，但不改变原分区的位置
	//创建一个结构体，包括分区大小和所对应的id，排序过程中，每改变顺序一次，id随着改变
	//关键：每次分配完一个进程的内存大小后，都要重新排序
	cout << "***********最佳适应算法***********" << endl;
	initial();
	int i, j, temp, tempID;

	sortNeed best[MAXNUMBER];
	for (i = 0; i<PartitionNum; i++)
	{
		//初始化结构体
		best[i].partitionSize = FreePartition[i];
		best[i].id = i;
	}

	for (i = 0; i<ProcessNum; i++)
	{
		for (int s = PartitionNum - 1; s > 0; s--)   //冒泡排序(每次分配完一个进程后，都需要重新排序)
		{
			for (int t = 0; t < s; t++)
			{
				if (best[s].partitionSize < best[t].partitionSize)
				{
					temp = best[s].partitionSize;
					best[s].partitionSize = best[t].partitionSize;
					best[t].partitionSize = temp;

					tempID = best[s].id;
					best[s].id = best[t].id;
					best[t].id = tempID;
				}
			}
		}

		for (j = 0; j<PartitionNum; j++)
		{
			if (LeftProcessNeed[i] <= best[j].partitionSize)
			{
				best[j].partitionSize -= LeftProcessNeed[i];
				LeftProcessNeed[i] = 0;

				NameProcessToPartition[i][best[j].id] = ProcessName[i];
				break;
			}
		}
		LeftFreePartition[best[j].id] = best[j].partitionSize;
	}

	display();
}

void WorstFit()
{
	cout << "***********最坏适应算法***********" << endl;
	initial();
	int i, j, s, t, tempSize, tempID;
	sortNeed Worst[MAXNUMBER];

	for (i = 0; i<PartitionNum; i++)
	{
		Worst[i].partitionSize = FreePartition[i];
		Worst[i].id = i;
	}

	for (i = 0; i<ProcessNum; i++)
	{
		for (s = PartitionNum - 1; s>0; s--)
		{
			for (t = 0; t<s; t++)
			{
				if (Worst[s].partitionSize > Worst[t].partitionSize)
				{
					tempSize = Worst[s].partitionSize;
					Worst[s].partitionSize = Worst[t].partitionSize;
					Worst[t].partitionSize = tempSize;

					tempID = Worst[s].id;
					Worst[s].id = Worst[t].id;
					Worst[t].id = tempID;
				}
			}
		}

		for (j = 0; j<PartitionNum; j++)
		{
			if (LeftProcessNeed[i] <= Worst[j].partitionSize)
			{
				Worst[j].partitionSize -= LeftProcessNeed[i];
				LeftProcessNeed[j] = 0;

				NameProcessToPartition[i][Worst[j].id] = ProcessName[i];
				break;
			}
		}
		LeftFreePartition[Worst[j].id] = Worst[j].partitionSize;
	}

	display();

}

void selectAlgorithm(int chooseAlgorithm)
{
	switch (chooseAlgorithm)
	{
	case 0:break;
	case 1:FirstFit(); break;
	case 2:NextFit(); break;
	case 3:BestFit(); break;
	case 4:WorstFit(); break;
	default:cout << "请输入正确的序号：" << endl;
	}
}

void display()
{
	int i;
	cout << "需要分配内存的进程名：" << setw(10);
	for (i = 0; i<ProcessNum; i++)
	{
		cout << ProcessName[i] << setw(6);
	}
	cout << endl;
	cout << "需要分配内存的进程分区大小：" << setw(4);
	for (i = 0; i<ProcessNum; i++)
	{
		cout << ProcessNeed[i] << setw(6);
	}
	cout << endl;
	cout << "分配结果：" << endl;

	cout << "分区序号:";
	for (i = 0; i<PartitionNum; i++)
	{
		cout << "分区" << i + 1 << " ";
	}
	cout << endl << "分区大小:";
	for (i = 0; i<PartitionNum; i++)
	{
		cout << FreePartition[i] << "     ";
	}
	cout << endl << "剩余大小: ";
	for (i = 0; i<PartitionNum; i++)
	{
		cout << LeftFreePartition[i] << "     ";
	}
	cout << endl << "分配进程情况:" << endl;
	for (i = 0; i<PartitionNum; i++)
	{
		for (int j = 0; j<ProcessNum; j++)
		{
			if (NameProcessToPartition[j][i] != NULL)
			{
				cout << NameProcessToPartition[j][i] << ": (分区" << i + 1 << ")" << endl;
			}
		}
		//cout<<"  ";
	}
	cout << endl << "********结束**********" << endl;
}

int main()
{
	input();
	return 0;
}

算法介绍

一、动态分区分配算法
为把一个新作业装入内存，须按照一定的分配算法， 从空闲分区表或空闲分区链中出一分区分配给该作业。由于内存分配算法对系统性能有很大的影响，故人们对它进行了较为广泛而深入的研究，于是产生了许多动态分区分配算法。传统的四种分配算法，它们都属于顺序式搜索算法。
二、分区分配操作
在动态分区存储管理方式中，主要的操作是分配内存和回收内存。
1)分配内存
系统应利用某种分配算法，从空闲分区链(表)中找到所需大小的分区。设请求的分区大小为u.size,表中每个空闲分区的大小可表示为m.size. 若m.size-u.size≤size(size是事先规定的不再切割的剩余分区的大小)，说明多余部分太小，可不再切割，将整个分区分配给请求者。否则(即多余部分超过size),便从该分区中按请求的大小划分出一块内 存空间分配出去，余下的部分仍留在空闲分区链(表)中。然后，将分配区的首址返回给调用者。图示出了分配流程。

2)回收内存
当进程运行完毕释放内存时，系统根据回收区的首址，从空闲区链(表)中找到相应的插入点，此时可能出现以下四种情况之一：
(1)回收区与插入点的前一个空闲分区F1 相邻接， 此时应将回收区与插入点的前一分区合并，不必为回收分区分配新表项，而只需修改其前一分区F的大小。如图（a）。
(2)回收分区与插入点的后一空闲分区F2相邻接，此时也可将两分区合并，形成新的空闲分区，但用回收区的首址作为新空闲区的首址，大小为两者之和。如图（b）
(3)回收区同时与插入点的前、后两个分区邻接。此时将三个分区合并，使用F的表项和F的首址，取消F2的表项，大小为三者之和。如图（c）。
(4)回收区既不与F邻接，又不与F2邻接。这时应为回收区单独建立一个新表项，填写回收区的首址和大小，并根据其首址插入到空闲链中的适当位置。

内存回收时流程图：

三、基于顺序搜索的动态分区分配算法

为了实现动态分区分配，通常是将系统中的空闲分区链接成一个链。所谓顺序搜索，是指依次搜索空闲分区链上的空闲分区，去寻找一个其大小能满足要求的分区。基于顺序搜索的动态分区分配算法有如下四种:首次适应算法、循环首次适应算法、最佳适应算法和最坏适应算法，下面分别进行介绍。

1.首次适应(first fit, FF)算法

我们以空闲分区链为例来说明采用FF算法时的分配情况。FF算法要求空闲分区链以地址递增的次序链接。在分配内存时，从链首开始顺序查找，直至找到一个大小能满足要求的空闲分区为止。然后再按照作业的大小，从该分区中划出一块内存空间，分配给请求者，余下的空闲分区仍留在空闲链中。若从链首直至链尾都不能找到一个能满足要求的分区，则表明系统中已没有足够大的内存分配给该进程，内存分配失败，返回。该算法倾向于优先利用内存中低址部分的空闲分区,从而保留了高址部分的大空闲区。这为以后到达的大作业分配大的内存空间创造了条件。其缺点是低址部分不断被划分，会
留下许多难以利用的、很小的空闲分区，称为碎片。而每次查找又都是从低址部分开始的，这无疑又会增加查找可用空闲分区时的开销。

2.循环首次适应(next fit，NF)算法

为避免低址部分留下许多很小的空闲分区，以及减少查找可用空闲分区的开销，循环首次适应算法在为进程分配内存空间时，不再是每次都从链首开始查找，而是从上次找到的空闲分区的下一个空闲分区开始查找，直至找到一一个能满足要求的空闲分区，从中划出一块 与请求大小相等的内存空间分配给作业。为实现该算法，应设置一起始查寻指针，用于指示下一次起始查寻的空闲分区，并采用循环查找方式，即如果最后一个(链尾)空闲分区的大小仍不能满足要求，则应返回到第一个空闲分区，比较其大小是否满足要求。找到后，应调整起始查寻指针。该算法能使内存中的空闲分区分布得更均匀，从而减少了查找空闲分区时的开销，但这样会缺乏大的空闲分区。

3.最佳适应(best fit，BF)算法

所谓“最佳”是指，每次为作业分配内存时，总是把能满足要求、又是最小的空闲分区分配给作业，避免“大材小用”。为了加速寻找，该算法要求将所有的空闲分区按其容量以从小到大的顺序形成——空闲分区链。这样，第一次找到的能满足要求的空闲区必然是最佳的。孤立地看，最佳适应算法似乎是最佳的，然而在宏观上却不一定。 因为每次分配后所切割下来的剩余部分总是最小的，这样，在存储器中会留下许多难以利用的碎片。

4.最坏适应(worst fit, WF)算法

由于最坏适应分配算法选择空闲分区的策略正好与最佳适应算法相反:它在扫描整个空闲分区表或链表时，总是挑选-一个最大的空闲区，从中分割一部分存储空间给作业使用，以至于存储器中缺乏大的空闲分区，故把它称为是最坏适应算法。实际上，这样的算法未必是最坏的，它的优点是可使剩下的空闲区不至于太小，产生碎片的可能性最小，对中、小作业有利。同时，最坏适应分配算法查找效率很高，该算法要求，将所有的空闲分区，按其容量以从大到小的顺序形成——空闲分区链，查找时，只要看第一个分区能否满足作业要求即可。

直接代码（实验原因封装在一块）

.h文件（头文件）

#pragma once
#include<iostream>
using namespace std;

typedef struct Node
{
	int pid;//分区号
	long size;//分区大小
	long start_locat;//分区起始地址
	int status;//分区状态
	struct Node* next;
	struct Node* perior;
}Node, *PNode;
void Init_list(PNode list);//初始化头结点
void Creat_list(PNode list);//初始化链表
PNode Insert_Node();//新插入链表
long* _Sort_min(long* p);//小到大因为实验量小采用冒泡排序
long* _Sort_max(long* p);//大到小因为实验量小采用冒泡排序
void First_fit(PNode list);//FF首次适应算法
void Next_fit(PNode list);//循环首次适应
void Best_fit(PNode list);//BF 最佳适应算法
void Worst_fit(PNode list);//最欢适应算法
void Release_Mem(PNode list);//回收内存
void Show(PNode list);

.cpp文件

#include<assert.h>
#include"list.h"

#define MAX_ALLOC_SIZE 600000
long start_add, end_add, memory_size;// 起始地址，终止地址，内存大小 
int free_num = 0;
Node* Flag_Node = NULL;
void Init_list(PNode list)
{
	assert(NULL != list);
	list->next =list;
	list->perior = list;
	list->start_locat = start_add;
	list->size = 0;
	list->status = 1;
}
void Creat_list(PNode list)
{
	assert(NULL != list);
	int _id = -1, _num = 0;
	long _size = -1;
	long _locat = list->start_locat;
	cout << "请输入申请资源的进程个数：" << endl;
	cin >> _num;
	for (int i = 0; i <= _num; i++)
	{
		Node* newnode = (Node*)malloc(sizeof(Node));
		assert(NULL != newnode);
		if (i < _num)
		{
           cout << "请输入第" << i + 1 << "个进程调入的分区号及其大小:" << endl;
		   cin >> _id >> _size;
		   newnode->pid = _id;
		   newnode->size = _size;
		   newnode->start_locat = _locat;
		   newnode->status = 1;
		   _locat += _size;
		}
		else
		{
			newnode->pid = -1;
			newnode->size = memory_size - _locat;
			newnode->start_locat = _locat;
			newnode->status = 0;
			free_num++;
		}
		PNode ptr = list;
		for (ptr; ptr->next != list; ptr = ptr->next);
		newnode->next = list;
		newnode->perior = ptr;
		ptr->next = newnode;
		list->perior = newnode;
	}
}
PNode Insert_Node()
{
	Node* newnode = (Node*)malloc(sizeof(Node));
	assert(NULL != newnode);
	int _id = 0;
	long _size = 0;
	cout << "请输入进程调入的分区号及其大小:" << endl;
	cin >> _id >> _size;
	newnode->next = NULL;
	newnode->perior = NULL;
	newnode->pid = _id;
	newnode->size = _size;
	newnode->start_locat = 0;
	newnode->status = 0;
	return newnode;

}
void First_fit(PNode list)
{
	assert(NULL != list);
	PNode _head = Insert_Node();
	PNode ptr = list;
	while (ptr->next != list)
	{
		PNode cur = ptr->next;
		if (cur->status==0&&cur->size > _head->size)
		{ 
			_head->next = cur;
			_head->perior = ptr;
             cur->perior = _head;
			 ptr->next = _head;
			_head->status = 1;
			_head->start_locat = ptr->start_locat + ptr->size;
			cur->start_locat = _head->start_locat + _head->size;
			cur->size = cur->size - _head->size;
			break;
		}
		else if (cur->status == 0&&cur->size == _head->size)
		{
			cur->pid = _head->pid;
			cur->status = 1;
			free_num--;
			break;
		}
		ptr = ptr->next;
	}
	if (ptr->next->status == 0)
	{
		cout << "没有适合的申请位置" << endl;
	}
}
void Next_fit(PNode list)
{
	assert(NULL != list);
	PNode _head = Insert_Node();
	PNode p = list;
	if (Flag_Node != NULL)
	{
		p = Flag_Node;
	}
	PNode ptr = p;
	while (ptr->next != p)
	{
		PNode cur = ptr->next;
		if (cur->status == 0 && cur->size > _head->size)
		{
			_head->next = cur;
			_head->perior = ptr;
			cur->perior = _head;
			ptr->next = _head;
			_head->status = 1;
			_head->start_locat = ptr->start_locat + ptr->size;
			cur->start_locat = _head->start_locat + _head->size;
			cur->size = cur->size - _head->size;
			Flag_Node = _head;
			break;
		}
		else if (cur->status == 0 && cur->size == _head->size)
		{
			cur->pid = _head->pid;
			cur->status = 1;
			Flag_Node = cur;
			free_num--;
			break;
		}
		ptr = ptr->next;
	}
	if (ptr->next->status == 0)
	{
		cout << "没有适合的申请位置" << endl;
	}
}
long* _Sort_min(long* p)
{
	assert(NULL != p);
	for (int i = 0; i < free_num-1; i++)
	{
		for (int j = 0; j < free_num - 1 - i; j++)
		{
			if (p[j] > p[j + 1])
			{
				long tmp = p[j];
				p[j] = p[j + 1];
				p[j + 1] = tmp;
			}
		}
	 }
	return p;
}
void Best_fit(PNode list)
{
	assert(NULL != list);
	PNode _head = Insert_Node();
	long* p = (long*)malloc(sizeof(long)*(free_num));
	assert(NULL!=p);
	PNode ptr = list->next;
	long i = 0, j = 0;
	while (ptr!= list)
	{
		if (ptr->status == 0)
		{
			*(p+i) = ptr->size;
			i++;
		}
		ptr = ptr->next;
	}
	long* q = _Sort_min(p);
	while (j < free_num)
	{
		if (_head->size < q[j])
		{
			break;
		}
		j++;
	}
	PNode cur = list;
	while (cur->next != list)
	{
		PNode tr = cur->next;
		if (tr->status==0&&tr->size == q[j])
		{
			if (_head->size < tr->size)
			{
				_head->next = tr;
				_head->perior = cur;
				tr->perior = _head;
				cur->next = _head;
				_head->status = 1;
				_head->start_locat = cur->start_locat + cur->size;
				tr->start_locat = _head->start_locat + _head->size;
				tr->size = tr->size - _head->size;
				break;
			}
			else if(_head->size==tr->size)
			{
				tr->pid = _head->pid;
				tr->status = 1;
				break;
			}
		}
		cur = cur->next;
	}
}
long* _Sort_max(long* p)
{
	assert(NULL != p);
	for (int i = 0; i < free_num - 1; i++)
	{
		for (int j = 0; j < free_num - 1 - i; j++)
		{
			if (p[j] <= p[j + 1])
			{
				long tmp = p[j];
				p[j] = p[j + 1];
				p[j + 1] = tmp;
			}
		}
	}
	return p;
}
void Worst_fit(PNode list)
{
	assert(NULL != list);
	PNode _head = Insert_Node();
	long* p = (long*)malloc(sizeof(long) * (free_num));
	assert(NULL != p);
	PNode ptr = list->next;
	long i = 0, j = 0;
	while (ptr != list)
	{
		if (ptr->status == 0)
		{
			*(p + i) = ptr->size;
			i++;
		}
		ptr = ptr->next;
	}
	long* q = _Sort_max(p);
	PNode cur = list;
	while (cur->next != list)
	{
		PNode tr = cur->next;
		if (tr->status == 0 && tr->size == q[j])
		{
			if (_head->size < tr->size)
			{
				_head->next = tr;
				_head->perior = cur;
				tr->perior = _head;
				cur->next = _head;
				_head->status = 1;
				_head->start_locat = cur->start_locat + cur->size;
				tr->start_locat = _head->start_locat + _head->size;
				tr->size = tr->size - _head->size;
				break;
			}
			else if (_head->size == tr->size)
			{
				tr->pid = _head->pid;
				tr->status = 1;
				break;
			}
		}
		cur = cur->next;
	}
}
void Release_Mem(PNode list)
{
	assert(NULL != list);
	int delet_id = 0;
	cout << "请输入需要回收的进程号：" << endl;
	cin >> delet_id;
	PNode ptr = list;
	while (ptr->next != list)
	{
		PNode cur = ptr->next;
		if (cur->pid == delet_id)
		{
			if (cur->status == 0)
			{
				cout << "回收错误请输入正确进程号" << endl;
				break;
			}
			else
			{
				if (ptr->status == 0&&cur->next->status==1)//1
				{
					ptr->size = ptr->size + cur->size;
					cur->next->perior = ptr;
					ptr->next = cur->next;
					free(cur);
					cur = NULL;
					break;
				}
				else if (ptr->status == 1 && cur->next->status == 0)//2
				{
					PNode p = cur->next;
					cur->size = cur->size + p->size;
					p->next->perior = cur;
					cur->next = p->next;
					cur->status = 0;
					free(p);
					p = NULL;
					break;
				}
				else if (ptr->status == 0 && cur->next->status == 0)//3
				{
					PNode p = cur->next;
					ptr->size = cur->size + ptr->size + p->size;
					p->perior = ptr;
					ptr->next = p;
					free(cur);
					cur = NULL;
					p->next->perior = ptr;
					ptr->next = p->next;
					free(p);
					p = NULL;
					free_num--;
					break;
				}
				else//4
				{
					cur->status = 0;
					free_num++;
					break;
				}
				
			}
			
		}
		ptr = ptr->next;
	}
}
void Show(PNode list)
{
	assert(NULL != list);
	printf("分区号码  分区大小  分区始址  分区状态\n"); 
	PNode ptr = list;
	while (ptr->next!=list)
	{    
		ptr = ptr->next;
		if (ptr->status == 0)
		{
			printf("%6d    %6dk    %6dk      空闲\n",ptr->pid, ptr->size,ptr->start_locat);
		}
		else
		{
			printf("%6d    %6dk    %6dk      占用\n",ptr->pid, ptr->size, ptr->start_locat);
		}
		
	}
}

.cpp文件（主函数）

int main()
{
	struct Node head;
	int select = 1;
	cout << "请输入请初始化内存块的首地址及内存大小：" << endl;
	cin >> start_add >> memory_size;
	if (memory_size > MAX_ALLOC_SIZE) {
		cout << "申请内存超过内存大小阈值！" << endl;
		return -1;
	}
	Init_list(&head);
	Creat_list(&head);
	Show(&head);
	while (1)
	{
		cout << "******************************************\n";
		cout << "*****1.******* 首次适应算法 ************\n";
		cout << "*****2.******循环首次适应算法 ************\n";
		cout << "*****3.******  最佳适应算法   ************\n";
		cout << "*****4.******  最坏适应算法   ************\n";
		cout << "*****5.*******   回收内存    *********\n";
		cout << "*****0.**********退出*********************\n";
		cout << "请选择:> ";
		cin >> select;
		switch (select)
		{
		case 1:
			First_fit(&head);
			Show(&head);
			break;
		case 2:
			Next_fit(&head);
			Show(&head);
			break;
		case 3:
			Best_fit(&head);
			Show(&head);
			break;
		case 4:
			Worst_fit(&head);
			Show(&head);
			break;
		case 5:
			Release_Mem(&head);
			Show(&head);
			break;
		default:
			break;
		}
	}
	return 0;
}

第一次写不太好见谅

（1）以首地址为0内存大小1024对链表初始化

（2）选用首次适应算法申请分区号为4大小为428的进程：

（3）为了方便 进行回收算法 第二第四未被回收。注意：回收有四种状态

（4）使用最佳适应算法 申请 12 大小26的分区：

（5）使用最坏适应算法 申请 分区号15 大小为88按照最佳适应为申请在2号分区但是最坏适应在最大分区 如下：

（6）循环首次自己试去…end
上课了 跑了。。。。。。。。。。。