操作系统——银行家算法（递归）

银行家算法

#include<iostream>
using namespace std;
#define NUM_PRO 4 //一共有多少个进程
#define NUM_RES 3 //资源的种类有多少
int allo[4][3]={{1,0,0},{5,1,1},{2,1,1},{0,0,2}};
int max[4][3]={{3,2,2},{6,1,3},{3,1,4},{4,2,2}};
int need[4][3]={{2,2,2},{1,0,2},{1,0,3},{4,2,0}};
class stack{
	public:
		int aval[3];
		int* bpnum;//栈底指针
		int* spnum;//栈顶指针 
		int used;
		stack(int aval[3]){
			used=0; 
			for(int i=0;i<=2;i++){
				this->aval[i]=aval[i];
			}
			bpnum=new int[10];
			for(int j=0;j<=9;j++){
				bpnum[j]=-1;
			} 
			spnum=bpnum; 
		}
		int get(int num){
			return bpnum[1+num];
		}
		int pop(){	
			if(spnum<=bpnum){
				return -1;
			}
			int aim=*spnum;
			*spnum=-1;
			spnum=spnum-1;
			used--;
			return aim;
		}
		int push(int aim){
			spnum=spnum+1;
			*spnum=aim;			
			used++;
			return *spnum;
		}
		stack* copy(){
			stack* ret=new stack(aval);
			ret->used=used;
			ret->spnum=ret->bpnum+used;
			for(int i=0;i<10;i++){
				ret->bpnum[i]=bpnum[i];
			}
			return ret;
		}
		void print(){
			cout<<"安全路径:";
			for(int i=0;i<NUM_PRO;i++){
				cout<<bpnum[i+1]<<"  ";
			}
			cout<<endl;
		}
		~stack(){
			delete[] bpnum;
		}
}; 
int judge(int judging,stack* judged){
	//判断各项资源是否充足 
	int i=0;
	for(i=0;i<NUM_RES;i++){
		if(need[judging][i]>judged->aval[i]){
			return -1;
		}
	}
	
	//本次judging资源足够 将这次的judging资源加上judged的资源 
	for(i=0;i<NUM_RES;i++){
		judged->aval[i]+=allo[judging][i];
	}

	//资源写入了 将judged push到栈中 
	judged->push(judging);
	
	//判断是否为最后一个 为最后一个需要进行输出
	if(judged->used==NUM_PRO){
		judged->print();
		return 1;
	}
	
	//对可以进行递归的进程检查
	bool bejudge=false;
	for(i=0;i<NUM_PRO;i++){							//对其他进程进行判断 
		for(int j=0;j<=judged->used;j++){			
			if(i==judged->get(j)){ 					//获得的是判断过的进程，若判断过这个进程就退出 
				bejudge=true;						 
				break;								//找到一个在stack中和i相同的进程 退出 
			}
		}
		if(bejudge==false){
			stack* next_judged=judged->copy();
			judge(i,next_judged);
			delete next_judged;
		}
		bejudge=false;
	}
	return 1;
}
int test(){
	//需要将剩余的资源和需要的资源对比，找出一条合适的路径，当找到合适的路径就将需要的资源加上程序释放的资源 
	int res[3]={1,1,2};
	stack* a=new stack(res);
	judge(0,a);									//选择进程a进行第一次判断
	stack* b=new stack(res); 
	judge(1,b);									//选择进程b进行第一次判断
	stack* c=new stack(res); 
	judge(2,c);									//选择进程c进行第一次判断 
	stack* d=new stack(res);
	judge(3,d); 								//选择进程d进行第一次判断 
	delete a;
	delete b;
	delete c;
	delete d; 
	return 0;
}
int main(){
	test();
	return 0;
} 

前面的类的定义可以写的简洁一点，主要的思路就是通过递归的方式，在test中进行4次judge()，每次判断的就是当首先分配给这个4个进程的某一个，是否会出现安全序列，判断过程如下：
当进入到judge函数中，我们首先分配给按照要求判断申请的judging号进程的要求是否可以满足，如果可以满足就分配给它，
将这个进程加入到栈中，
然后进行一个判断，当判断结果为栈中已经有了对应的进程数目，表示完成了所有分配，输出安全分配序列
如果没有分配完成，就进行余下的判断，找出没有被分配的进程的进行再一次的分配

时间复杂度：学艺不精时间复杂度大概为O(n!)还要多