银行家算法

算法思路：

1. 当用户申请一个资源的时候， 判断把资源分配出去以后系统是否还处于安全的状态， 如果系统还处于安全的状态，那么就把这些资源分配出去， 否则就不分配出去。
2. 检查系统是否处于安全状态的算法：

1】定义若干的数据结构，

typeNumber 资源种类数

numProcess 进程数

available 是一个长度为typeNumber的向量，表示每一类资源的可用数量

int ** allocation 是一个numProcess * typeNumber的二维矩阵，它表示当前分配给每个进程的资源数， 比如allocation[i][j] = k 表示当前进程 pi  分配到j类资源的数目是K

int  ** Max 是一个numProcess * typeNumber的二维矩阵，它表示进程对某个资源的最大需求。 比如 Max[i][j] = k 表示 进程 pi 对j类资源的最大需求是K

int ** need 是一个numProcess * typeNumber的二维矩阵， 它表示某个进程对某个资源的还需要多少。 比如 need[i][j] = k 表示进程 pi 对j类资源还需要 k 才可以执行完。

int * path  是一个长度为numProcess + 10 的一维向量， 它储存安全序列。

2】安全序列算法思路：

1)令 Work 和 finish分别表示长度为typeNumber ， numProcess 的向量，并初始化 Work: = available  finish[i]: = false (i = 0，1， 2，......numProcess )

2)搜索满足 finish[i] = false 且 needi  <= work 的 i值 （实际就是查找可以分配资源的进程 pi）,如果找到这样的i就转到以下步骤3)，否则就转到步骤四

 

1. 修改数值：finish[i]  = true Work: = Work + allocationi (进程pi所释放的各类资源) ，继续转向步骤2）
2. 检查所有的 i ，判断 finish[i]是否都是 true ,如果是的话，那么系统处于安全的状态， 否则就不是处于安全的状态。

 

#include<iostream>
#include<cstdio>
using namespace std;


int typeNumber;//资源种类数
int numProcess;//进程个数

int **allocation;//分配矩阵
int **Max;//最大需求矩阵
int **need;//尚且需要分配的资源矩阵
int * available;//可利用资源一维数组
int *path;//储存安全路径
int len = 0;//记录安全路径长度
void initMatrix(const int & row, const int & n){//初始化二维矩阵的行数和列数
	
	//初始化二维矩阵的维数
	allocation = new int*[row];
	Max = new int*[row];
	need = new int*[row];

	//初始化二维矩阵的列数
	for(int i = 0; i < row; i++){
		allocation[i] = new int[n];
		Max[i] = new int[n];
		need[i] = new int[n];
	}

}

//检查进程pId对各类资源的需求量是否小于等于当前各类资源可使用量
bool checkNeed(int pId, int * Work){
	for(int i = 0; i < typeNumber; i++){
		if(need[pId][i] > Work[i])//进程<pId>对i类资源的需求量大于可使用量
			return  false;
	}
	return true;

}

bool isSafe(){//检查是否有安全序列
	int * Work = new int[typeNumber];//记录当前每类资源的可利用数量，长度等于资源个数
	bool * finish = new bool[numProcess];//长度等于进程数目

	for(int i = 0; i < typeNumber; i++)
		Work[i] = available[i];//初始为available 数组
	for(int i = 0; i < numProcess; i++)//初始为false,false表示进程i没有分配好资源
		finish[i] = false;

	int i;
	for(i = 0; i < numProcess; ){//扫描每个进程
		if(finish[i] == false && checkNeed(i, Work)){//如果这个进程没有分配资源且当前可分配资源
			for(int k = 0; k < typeNumber; k++)
				Work[k] += allocation[i][k];//释放进程pi的各类资源
			finish[i] = true;//标记进程pi可以执行，加入了安全序列
			path[len++] = i;//加入安全序列
			
			i = 0;//继续从头开始找
		}
		else 
			i++;//找下一个是否满足
	}


	for(int i = 0; i < numProcess; i++){
		if(finish[i] == false)
			return false;//有进程不能执行，不存在安全序列
	}

	return true;//所有进程可安全执行 


}

void output(){//输出安全路径
	for(int i = 0; i < len; i++){
		printf("p%d ", path[i]);
	}
	cout<<endl;

}


int main()
{

	printf("输入系统资源的种类数\n");
	scanf("%d", &typeNumber);

	available = new int[typeNumber];//记录每类资源的可用数

	printf("请输入每个资源的初始数\n");

	for(int i = 0; i < typeNumber; i++){
		printf("请输入资源 %c 的初始数量： ", 'A' + i);
		int temp;
		scanf("%d", &temp);
		available[i] = temp;
	}


	printf("输入内存中的进程数\n");
	scanf("%d", &numProcess);

	path = new int[numProcess + 10];//储存安全路径的数组

	initMatrix(numProcess, typeNumber);//初始化Max,allocation, need矩阵

	printf("请输入已分配资源矩阵 \n");

	for(int i = 0; i < numProcess; i++){
		int resource;//已分配的资源数目
		for(int j = 0; j < typeNumber; j++)
		{
			printf("请输入分配给进程 p%d 的 %c 种资源数目: ", i, 'A' + j);
			scanf("%d", &resource);
			allocation[i][j] = resource;//将resource个资源分配给进程i
			available[j] -= resource;//分配之后j类可用资源减少resource
			
		}

	}

	printf("请输入最大需求矩阵\n");

	for(int i = 0; i < numProcess; i++){
		int maxDemand;
		for(int j = 0; j < typeNumber; j++)
		{
			printf("请输入分配给进程 p%d 的 %c 种资源最大需求: ", i, 'A' + j);
			scanf("%d", &maxDemand);//输入最大需求
			Max[i][j] = maxDemand;//初始化进程pi对j类资源最大需求
			need[i][j] = Max[i][j] - allocation[i][j];//求进程pi对j类资源尚需多少
		}

	}

	
	if(isSafe()){//判序列断是否存在安全
		cout<<"存在安全的序列: ";
		output();//输出安全路径
	}
	else 
		cout<<"不存在安全序列"<<endl;


	system("pause");

}