动态分区分配算法

设计程序模拟四种动态分区分配算法：首次适应算法、循环首次适应算法、最佳适应算法和最坏适应算法的工作过程。假设内存中空闲分区个数为n，空闲分区大小分别为P1, … ,Pn，在动态分区分配过程中需要分配的进程个数为m（m≤n），它们需要的分区大小分别为S1, … ,Sm，分别利用四种动态分区分配算法将m个进程放入n个空闲分区，给出进程在空闲分区中的分配情况。

程序要求：

1）利用首次适应算法、循环首次适应算法、最佳适应算法和最坏适应算法四种动态分区分配算法模拟分区分配过程。

2）模拟四种算法的分区分配过程，给出每种算法进程在空闲分区中的分配情况。

3）输入：空闲分区个数n，空闲分区大小P1, … ,Pn，进程个数m，进程需要的分区大小S1, … ,Sm，算法选择1-首次适应算法，2-循环首次适应算法，3-最佳适应算法，4-最坏适应算法。

4）输出：最终内存空闲分区的分配情况。

完整代码

#include <iostream>
#include <stdlib.h>
#include <iomanip>
using namespace std;
const int MaxNumber=100;
int  FreePartition[MaxNumber];	//空闲分区 
int  FirstPartition[MaxNumber];  //首次适应
int  CycleFirstPartition[MaxNumber];  // 循环首次适应
int  BestPartition[MaxNumber];  //最佳适应 
int  WorstPartition[MaxNumber];  //最坏适应 
int  ProcessNeed[MaxNumber];	//进程所需分区大小 
int  CopyPartition[MaxNumber];	//复制进程 
int n, m; //n分区，m进程 
 
void output() {
	cout<<"进程信息如下："<<endl;
	cout<<"---------------------------------------------------"<<endl;
	cout<<left<<setw(12)<<"分区号"<<setw(12)<<"分区大小"<<setw(12)<<"剩余大小"<<setw(12)<<"分区是否被使用"<<endl;
	cout<<"---------------------------------------------------"<<endl;
}
//输出首次适应 
void outFirst() {
	output();
	for(int i=0;i<n;i++){
		cout<<left<<setw(12)<<i;
		cout<<setw(12)<<CopyPartition[i];
		cout<<setw(12)<<CopyPartition[i]-FirstPartition[i];
		if(FreePartition[i] != CopyPartition[i]){
			cout<<"true";
		}else{
			cout<<"false";
		}
		cout<<endl;
	}
	cout<<"---------------------------------------------------"<<endl;
}
//首次适应 
void first() {
	for(int i = 0; i < n; i++) {
		FirstPartition[i] = 0;
	}
	for(int i = 0; i < m; i++) {
		for(int j = 0; j < n; j++) {
			if(ProcessNeed[i] <= FreePartition[j]) {//可以分配 
				FirstPartition[j] += ProcessNeed[i];
				FreePartition[j] -= ProcessNeed[i];
				//cout<<FreePartition[j]<<endl;
				cout<<"进程"<<i<<"分配给"<<j<<"号空闲区"<<endl;
				break;
			}
		}
	}
	cout<<endl;
	outFirst();
}
//输出循环首次适应 
void outCircleFirst() {
	output();
	for(int i=0;i<n;i++){
		cout<<left<<setw(12)<<i;
		cout<<setw(12)<<CopyPartition[i];
		cout<<setw(12)<<CopyPartition[i]-CycleFirstPartition[i];
		if(FreePartition[i] != CopyPartition[i]){
			cout<<"true";
		}else{
			cout<<"false";
		}
		cout<<endl;
	}
	cout<<"---------------------------------------------------"<<endl;
}
 
//循环首次适应 
void circleFirst() {
	for(int i = 0; i < n; i++) {
		CycleFirstPartition[i] = 0;
	}
	int pointer = 0;//记录上次查找的位置 
	for(int i = 0; i < m; i++) {
		for(int j = pointer; j < n; j++) {
			if(ProcessNeed[i] <= FreePartition[j]) {//可以分配 
				CycleFirstPartition[j] += ProcessNeed[i];
				FreePartition[j] -= ProcessNeed[i];
				pointer = j;
				cout<<"进程"<<i<<"分配给"<<j<<"号空闲区"<<endl;
				break;
			}
			if(j == n - 1) {
				pointer = 0;
			}
		}
	}
	cout<<endl;
	outCircleFirst();
}
//输出最佳适应 
void outBest() {
	output();
	for(int i=0;i<n;i++){
		cout<<left<<setw(12)<<i;
		cout<<setw(12)<<CopyPartition[i];
		cout<<setw(12)<<CopyPartition[i]-BestPartition[i];
		if(FreePartition[i] != CopyPartition[i]){
			cout<<"true";
		}else{
			cout<<"false";
		}
		cout<<endl;
	}
	cout<<"---------------------------------------------------"<<endl;
}
 

//最佳适应   先给小的区分配 
void best() {
	
	for(int i = 0; i < n; i++) {
		BestPartition[i] = 0;
	}
	for(int i = 0; i < m; i++) {
		int min = 100000; //表示无穷大 
		int flag = -1;
		for(int j = 0; j < n; j++) {
			if(FreePartition[j] - ProcessNeed[i] < min && ProcessNeed[i] <= FreePartition[j]) {
				min = FreePartition[j] - ProcessNeed[i];
				flag = j;
			}
		}cout<<"进程"<<i<<"分配给"<<flag<<"号空闲区"<<endl;
		if(flag != -1) {
			BestPartition[flag] += ProcessNeed[i];
			FreePartition[flag] -= ProcessNeed[i];
		}
	}
	cout<<endl;
	outBest();
}
//输出最坏适应  
void outWorse() {
	output();
	for(int i=0;i<n;i++){
		cout<<left<<setw(12)<<i;
		cout<<setw(12)<<CopyPartition[i];
		cout<<setw(12)<<CopyPartition[i]-WorstPartition[i];
		if(FreePartition[i] != CopyPartition[i]){
			cout<<"true";
		}else{
			cout<<"false";
		}
		cout<<endl;
	}
	cout<<"---------------------------------------------------"<<endl;
}
//最坏适应  按照空闲区从大到小分配 
void worse() {
	for(int i = 0; i < n; i++) {
		WorstPartition[i] = 0;
	}
	for(int i = 0; i < m; i++) {
		int max = 0; //表示无穷大 
		int flag = -1;
		for(int j = 0; j < n; j++) {
			if(FreePartition[j] - ProcessNeed[i] > max && ProcessNeed[i] <= FreePartition[j]) {
				max = FreePartition[j] - ProcessNeed[i];
				//cout<<"进程"<<i<<"分配给"<<j<<"号空闲区"<<endl;
				flag = j;
			}
		}
		cout<<"进程"<<i<<"分配给"<<flag<<"号空闲区"<<endl;
		if(flag != -1) {
			WorstPartition[flag] += ProcessNeed[i];
			FreePartition[flag] -= ProcessNeed[i];
		}
	}
	cout<<endl;
	outWorse();
}
 
void menu(){
	cout<<endl;
	cout<<"算法清单"<<endl;
	cout<<"1.首次适应算法（FF）"<<endl;
	cout<<"2.循环首次适应算法（NF）"<<endl;
	cout<<"3.最佳适应算法（BF）"<<endl;
	cout<<"4.最坏适应算法（WF）"<<endl;
	cout<<"0.退出程序（EXIT）"<<endl;
	cout<<endl;
}

int main() {
	cout<<"--------------------动态分区分配算法--------------------"<<endl; 
	int choice;
	cout<<"请输入空闲分区数"<<endl;
	cin>>n;
	cout<<"请输入"<<n<<"个空闲分区的大小"<<endl;
	for(int i = 0; i < n; i++) {
		cin>>FreePartition[i];
	}
	for(int i = 0; i < n; i++) {
		CopyPartition[i] = FreePartition[i];
	}
	cout<<"请输入进程个数"<<endl;
	cin>>m;
	cout<<"请输入"<<m<<"个进程的大小"<<endl;
	for(int i = 0; i < m; i++) {
		cin>>ProcessNeed[i];
	}
	do{
		menu();
		cout<<"请选择要进行的操作：";
		cin>>choice;
		cout<<endl;
		switch(choice){
			case 1:
				cout<<"使用首次适应算法"<<endl;
				first();
				break;
			case 2:
				cout<<"使用循环首次适应算法"<<endl;
				circleFirst();
				break;
			case 3:
				cout<<"使用最佳适应算法"<<endl;
				best();
				break;	
			case 4:
				cout<<"使用最坏适应算法"<<endl;
				worse();
				break; 
			case 0:
				cout<<"程序终止！"<<endl;
				return 0;
		}
		cout<<endl;
		system("pause");
	}while(choice);
	return 0;
}

实例运行结果截图：

空闲分区数：9

9个空闲分区的大小：16 16 8 32 64 32 8 16 64

进程个数：6

6个进程的大小：7 18 9 20 35 8

首次适应算法：

循环首次适应算法：

最佳适应算法：

最坏适应算法：