银行家算法，c++实现

在这个银行家算法里面：

1.进程有初始资源data1

2.进程有最大需求资源data2

3.系统有未分配资源Idata

4.当进程需要的最大资源被满足，资源会被立刻回收

5.进程数不会更新

本次的代码仅满足上面的要求

如果需要其他的要求，请适当修改代码

改进方面：

1.可以修改未vector的数组形式

2.如果进程数是会实时改变，请添加新的函数更新数组data1，data2，然后调用函数处理data3即可

//bm.h/////
#include 
#include 
#include 
using namespace std;

#define M 5

///////定义结构////////////
struct Idata
{
	int id;
	int key;
};


////////////   函数   ///////////

//初始化数据集
void setdata(int da[][M], int da2[][M], int da3[][M]);
//初始化资源集
void setIdata(Idata *item);
//排序资源数
void sortidata(Idata *idata, queue  &ind);
void quicksort(Idata *item, int m, int n);
//处理满足需求的事务
bool getdata(int d3[][M], Idata *idata, queue  &ind, queue  &fu);
//回收资源
void freedata(Idata *item, int d1[][M], queue  &fu, stack  &st);
//处理原有数据
void cleardata(int d1[][M], int d2[][M], int d3[][M], stack  &fu, bool *&fl);
//需要处理的进程数
void dep(bool *fl, queue  &ind);
//循环
void dg(int d1[][M], int d2[][M], int d3[][M], Idata *Id1, bool *f, queue  inde, queue  fu, stack  st);

///////////预处理/////
void setarray1(bool *item);
bool flg(bool *f);
bool change(bool t1, bool t2);
void dshow(Idata *item);
void ddshow(int da[][M]);


//bm.cpp////
#include "bm.h"

//初始化数据集
void setdata(int d1[][M], int d2[][M], int d3[][M])
{
	cout << "输入已分配的资源数\n";
	/*	for (int i = 0; i < M; i++)
	{
	for (int j = 0; j < M; j++)
	{
	cin >> d1[i][j];
	}
	}
	*/
	cout << "输入须分配的总资源数\n";
	/*	for (int i = 0; i < M; i++)
	{
	for (int j = 0; j < M; j++)
	{
	cin >> d2[i][j];
	}
	}
	*/
	for (int i = 0; i < M; i++)
	{
		for (int j = 0; j < M; j++)
		{
			d3[i][j] = d2[i][j] - d1[i][j];
		}
	}
	cout << "以初始化已分配的资源！\n";
	return;
}
//初始化资源集
void setIdata(Idata *idata)
{
	cout << "输入未分配的资源数\n";
	for (int i = 0; i < M; i++)
	{
		idata[i].id = i;
		cin >> idata[i].key;
	}
	cout << "已初始化未分配资源！\n";
	return;
}
//排序资源数
void sortidata(Idata *idata, queue  &ind)
{
	Idata l[M];
	for (int i = 0; i < M; i++)
	{
		l[i] = idata[i];
	}
	quicksort(l, 0, M - 1);
	for (int i = 0; i < M; i++)
	{
		ind.push(l[i].id);
		//cout << l[i].id << "+"<a&&item[b].key >= c.key) b--;//从后面往前面遍历，直到找到比头 标准r 小的 
			item[a] = item[b];
			while (a &ind, queue  &fu)
{
	bool t1 = true;
	fu.push(-1);
	while (!ind.empty())
	{		while (fu.front() != -1)
		{

			if (d3[fu.front()][ind.front()] <= idata[ind.front()].key)
			{
				//int f = fu.front(); fu.push(f);
				fu.push(fu.front());
			}
			fu.pop();
		}
		fu.pop();
		if (!fu.empty())
		{
			fu.push(-1);
		}
		else 
		{
			t1 = false;
			return t1;
		}
		ind.pop();
	}
/*	queue  test = fu;
	while (!test.empty())
	{
		cout << test.front();
		test.pop();
	}*/
	return t1;
}
//回收资源
void freedata(Idata *item, int d1[][M], queue  &fu, stack  &st)
{
	while (fu.front() != -1)
	{
		st.push(fu.front());
		for (int i = 0; i < M; i++)
		{
			item[i].key += d1[fu.front()][i];
		}
		fu.pop();
	}
	fu.pop();
	//if (fu.empty())cout << "yes";
	return;
}
//处理原有数据
void cleardata(int d1[][M], int d2[][M], int d3[][M], stack  &st, bool *&fl)
{
	//st.pop();
	int x;
	while (!st.empty())
	{
		x = st.top();
		fl[x] = false;
		for (int i = 0; i < M; i++)
		{
			d1[x][i] = d2[x][i] = d3[x][i] = 0;
		}
		st.pop();
	}
	return;
}
//需要处理的进程数
void dep(bool *fl, queue  &ind)
{
	for (int i = 0; i < M; i++)
	{
		if (fl[i])
		{
			ind.push(i);
		}
	}
	return ;
}

/////递归实现 ////////
void dg(int d1[][M], int d2[][M], int d3[][M], Idata *Id1, bool *f, queue  inde, queue  fu,stack  st)
{
	bool ff = true,t1,t2;
	while (ff)
	{
		sortidata(Id1, inde);
		dep(f, fu); //cout << "进程可选模式\n";
		t1=getdata(d3, Id1, inde, fu);// cout << "已获得可分配的进程\n";
		t2 = flg(f);
		ff = change(t1, t2);
		if (ff == false) return;
		freedata(Id1, d1, fu, st);// cout << "已回收资源\n";
		cleardata(d1, d2, d3, st, f); //cout << "已清除数据集\n";
		//ddshow(d1);
		//dshow(Id1);
	}
	return;
}

/////预处理////
void setarray1(bool *item)
{
	for (int i = 0; i < M; i++)
		item[i] = true;
	return;
}
bool flg(bool *f)
{
	bool t2 = false;
	for (int i = 0; i < M; i++)
	{
		if (f[i] == true) t2 = true;
		//else t2 = false;
	}
	return t2;
}
bool change(bool t1, bool t2)
{
	if (t1 + t2 == 2) return true;
	else
	{
		if (t1 == false && t2 == true)
		{
			cout << "不安全模式！";
			return false;
		}
		else if (t2==false)
		{
			cout << "安全模式"; return false;
		}
	}
}
void dshow(Idata *item)
{
	for (int i = 0; i < M; i++)
		cout << item[i].key << " ";
}
void ddshow(int da[][M])
{
	for (int i = 0; i < M; i++)
	{
		for (int j = 0; j < M; j++)
			cout << da[i][j] << " ";
		cout << endl;
	}
}

//main///
#include "bm.h"

int main()
{
	int data1[M][M] = { { 0, 2, 1, 1, 0 }, { 1, 2, 0, 0, 0 }, { 1, 2, 2, 0, 1 }, { 1, 1, 0, 0, 2 }, { 1, 1, 1, 1, 1 } };
	int data2[M][M] = { { 0, 2, 3, 2, 0 }, { 3, 3, 1, 1, 0 }, { 3, 2, 3, 1, 1 }, { 2, 2, 0, 1, 2 }, { 2, 2, 2, 2, 2 } };//安全模式
//	int data2[M][M] = { { 0, 2, 3, 2, 0 }, { 3, 13, 1, 1, 0 }, { 3, 2, 3, 1, 1 }, { 2, 2, 0, 1, 2 }, { 2, 2, 2, 2, 2 } };//不安全模式
	int data3[M][M];
	Idata Id[M];//可用检验实例 1 2 2 1 1
	bool flage[M];
	queue  indeed;
	queue  full;
	stack  st;
	////////////////////////////////
	setarray1(flage);
	setdata(data1, data2, data3);
	setIdata(Id);
	//////////
	dg(data1, data2, data3, Id, flage,indeed, full, st);
	/////////
	system("pause");
	return 0;
}