银行家算法
#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!)还要多