银行家算法模拟-----c++语言(其实质也是c语言)

最新推荐文章于 2024-07-01 12:04:31 发布
最新推荐文章于 2024-07-01 12:04:31 发布
阅读量905 收藏 1
点赞数
分类专栏： 个人随笔 文章标签： 语言 算法 c input allocation 作业
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fangcao90/article/details/4051110
版权

#include<iostream.h>
#define MaxP 10
#define MaxR 10
/*---判断指定进程执行某此请求时,是否安全!---*/
int issafe(int Request[],int Avai[],int Max[][MaxR],int Need[][MaxR],int Allo[][MaxR],int r,int n);
/*---判断指定的进程是否完成!---*/
int isfinish(int Allo[][MaxR],int Max[][MaxR],int Finish[],int n,int r);
/*---对指定完成的进程进行内存回收!---*/
void cycle(int Avai[],int Allo[][MaxR],int n,int r);
void main()
{
 int Avai[MaxR];                //System total Resource
 int Max[MaxP][MaxR];      //all Process of all kinds of Resource
 int Allo[MaxP][MaxR];      //all Process has get Resource current
 int Need[MaxP][MaxR];      //all Process still need Resource
 int Finish[MaxP];               //all Process wherther finish
 int Request[MaxR];       //current Request Resource number
 int i,j,k=1;                 //temporary value
 int p;          //Process number
 int r;          //Resource number
 int n;          //Request Process number
 cout<<"input How many Process(small "<<MaxP<<"):";
 cin>>p;
 cout<<"input How many Resource(small "<<MaxR<<"):";
 cin>>r;
 cout<<"input initat number all kinds of Resource:"<<endl;
 for(i=0;i<r;i++){
  cin>>Avai[i];
 }
 cout<<"input number all kinds of MaxResource of Process"<<endl;
 for(i=0;i<p;i++){
  for(j=0;j<r;j++){
   cin>>Max[i][j];
   Need[i][j]=Max[i][j];    //对进程资源进行初始化
   Allo[i][j]=0;
  }
 Finish[i]=0;
 }
 while(k!=0){
  cout<<"*****银行家算法测试系统*****"<<endl;
     cout<<"*****1.作业请求资源!********"<<endl;
  cout<<"*****2.查看作业当前资源情况!"<<endl;
  cout<<"*****3.执行当前可以完成的作业!"<<endl;
  cout<<"*****0.退出!****************"<<endl;
  cout<<"/t choic(0~2):";
  cin>>k;
  switch(k){
  case 0:
   break;
  case 1:
   cout<<"input the Process of number which request the Resource(samll "<<p<<"):"<<endl;
   cin>>n;
   while(isfinish(Allo,Max,Finish,n,r)){    //直到输入没有完成的进程为止
    cout<<"作业已经完成,请重新输入!"<<endl;
    cin>>n;
   }
   cout<<"input this Process of all kinds of Resource number:"<<endl;
   for(i=0;i<r;i++){
    cin>>Request[i];
   }
   if(issafe(Request,Avai,Max,Need,Allo,r,n)){   //判断指定的进程的请求是否安全,从而决定是否接受请求
    cout<<"accept the Request!"<<endl;
    Finish[n]=0;
    if(isfinish(Allo,Max,Finish,n,r)){     //接受请求后判断是否完成,如果完成则进行内存回收
     cycle(Avai,Allo,n,r);
    }
   }else{
    cout<<"this Request is refuse,please Wait!"<<endl;
    Finish[n]=2;
   }
   break;
  case 2:
   cout<<"当前资源分布状况!"<<endl;
   cout<<"当前剩下的总资源有";
   for(i=0;i<r;i++){         //按一定格式进行信息显示
    cout<<Avai[i]<<" ";
   }
   cout<<endl;
   cout<<"Max /t/t Need /t/t Allocation /t State"<<endl;
   for(i=0;i<p;i++){
    cout<<"(";
    for(j=0;j<r;j++){
     cout<<Max[i][j]<<",";
    }
    cout<<") /t";
    cout<<"(";
    for(j=0;j<r;j++){
     cout<<Need[i][j]<<",";
    }
    cout<<") /t";
    cout<<"(";
    for(j=0;j<r;j++){
     cout<<Allo[i][j]<<",";
    }
    cout<<")";
    if(Finish[i]==1){
     cout<<"/t Finish"<<endl;
    }else if(Finish[i]=0){
     cout<<"/t Running"<<endl;
    }else if(Finish[i]==2){
     cout<<"/t Wating"<<endl;
    }
   }
   break;
  case 3:
   int flag=0;      //找到定第一个可以执行的进程
   for(i=0;i<p;i++){
    if(Finish[i]==1){
     continue;
    }
    for(j=0;j<r;j++){
     if(Avai[j]<Need[i][j]){
      break;
     }
     if(r==j+1){
      flag=1;
      break;
     }
    }
    if(flag==1){    //如果找到,则执行,并进行一定的内存回收
     Finish[i]=1;
     cycle(Avai,Allo,i,r);
     for(j=0;j<r;j++){
      Need[i][j]=0;
      Allo[i][j]=Max[i][j];
     }
     break;
    }
   }
   
   break;
  }
 }
}

/*---判断指定进程执行某此请求时,是否安全!---*/
int issafe(int Request[],int Avai[],int Need[][MaxR],int Allo[][MaxR],int r,int n,int p){
 int i,j,k,count=0,flag;
 int Needn[MaxR];
 int Avain[MaxR];           //记录当前可用资源的分布情况
 int Avai_n[MaxR];           //保存预先分配的资源状况
 int isFinish[MaxP];           //判断进程是否执行完成
 for(i=0;i<r;i++){
  if(Request[i]>Need[n][i] || Request[i]>Avai[i]){  //对请求进行合法性判断
   return 0;
  }
 }
 for(i=0;i<r;i++){           //对请求的资源分配先进行一些预处理
  Needn[i]=Need[n][i]-Request[i];       
  Avain[i]=Avai[i]-Request[i];
  Avai_n[i]=Avain[i];
 }
 for(k=0;k<p;k++){
  isFinish[k]=0;
 }

 for(k=0;k<p;k++){           //进行安全性检测
  for(j=0;j<p;j++){
   flag=1;            //判断该进程是否可以执行的标志
   if(isFinish[j]!=0){         //判断进程是否执行完成
    continue;
   }
   for(i=0;i<r;i++){         //对每个资源进行判断，是否可以执行
    if(j!=n){          //由于刚申请的资源没有通过安全测试，所以还没有进行分配，必须作特殊处理
     if(Need[j][i]>Avain[i]){
      flag=0;
      break;
     }
    }else{
     if(Needn[i]>Avain[i]){
      flag=0;
      break;
     }
    }
   }
   if(flag==1){
    for(i=0;i<r;i++){
     if(j!=n){
      Avain[i]+=Allo[j][i];
     }else{
      Avain[i]+=Request[i]+Allo[n][i];  //由于刚申请的资源没有通过安全测试，所以还没有进行分配，必须作特殊处理
     }
    }
    count++;
    isFinish[j]=count;        //为了记录安全执行的顺序
    break;
   }
  }
 }

 if(count!=p){            //对以上安全算法结果的最终判断
  return 0;
 }

 for(i=0;i<p;i++){
  cout<<isFinish[i]<<",";
 }
 cout<<endl;

 for(i=0;i<r;i++){           //如果安全则进行资源分配
  Allo[n][i]=Allo[n][i]+Request[i];
  Need[n][i]=Needn[i];
  Avai[i]=Avai_n[i];
 }
 return 1;
}

/*---判断指定的进程是否完成!---*/
int isfinish(int Allo[][MaxR],int Max[][MaxR],int Finish[],int n,int r){
 int i;
 for(i=0;i<r;i++){
  if(Allo[n][i]!=Max[n][i]){
   return 0;
  }
 }
 Finish[n]=1;
 return 1;
}
/*---对指定完成的进程进行内存回收!---*/
void cycle(int Avai[],int Allo[][MaxR],int n,int r){
 int i;
 for(i=0;i<r;i++){
  Avai[i]=Avai[i]+Allo[n][i];
 }
}

fangcao90
关注
专栏目录
银行家算法
Hb_key的博客
01-06 2443
#define _CRT_SECURE_NO_WARNINGS #include &amp;lt;iostream&amp;gt; #include &amp;lt;stdio.h&amp;gt; #include &amp;lt;string&amp;gt; #include &amp;lt;iomanip&amp;gt; #include &amp;lt;stdbool.h&amp;gt; using namespace s
软考中级-软件设计师 知识点整理（一篇就过了 建议收藏）
热门推荐
Y的博客
09-23 11万+
软考中级-软件设计师上午题知识点总结
银行家算法（c语言）
01-18
操作系统课的实验（银行家算法）#include "malloc.h" 　　#include "stdio.h" 　　#include "stdlib.h" 　　#define alloclen sizeof(struct allocation) 　　#define maxlen sizeof(struct max) 　　#define avalen sizeof(struct available) 　　#define needlen sizeof(struct need) 　　#define finilen sizeof(struct finish) 　　#define pathlen sizeof(struct path) 　　struct allocation 　　{ 　　int value; 　　struct allocation *next; 　　}; 　　struct max 　　{ 　　int value; 　　struct max *next; 　　}; 　　struct available /*可用资源数*/ 　　{ 　　int value; 　　struct available *next; 　　}; 　　struct need /*需求资源数*/ 　　{ 　　int value; 　　struct need *next; 　　}; 　　struct path 　　{ 　　int value; 　　struct path *next; 　　}; 　　struct finish 　　{ 　　int stat; 　　struct finish *next; 　　}; 　　int main() 　　{ 　　int row,colum,status=0,i,j,t,temp,processtest; 　　struct allocation *allochead,*alloc1,*alloc2,*alloctemp; 　　struct max *maxhead,*maxium1,*maxium2,*maxtemp; 　　struct available *avahead,*available1,*available2,*workhead,*work1,*work2,*worktemp,*worktemp1; 　　struct need *needhead,*need1,*need2,*needtemp; 　　struct finish *finihead,*finish1,*finish2,*finishtemp; 　　struct path *pathhead,*path1,*path2; 　　printf("\n请输入系统资源的种类数:"); 　　scanf("%d",&colum); 　　printf("请输入现时内存中的进程数:"); 　　scanf("%d",&row); 　　printf("请输入已分配资源矩阵:\n"); 　　for(i=0;i<row;i++) 　　{ 　　for (j=0;jnext=alloc2->next=NULL; 　　scanf("%d",&allochead->value); 　　status++; 　　} 　　else 　　{ 　　alloc2=(struct allocation *)malloc(alloclen); 　　scanf("%d,%d",&alloc2->value); 　　if(status==1) 　　{ 　　allochead->next=alloc2; 　　status++; 　　} 　　alloc1->next=alloc2; 　　alloc1=alloc2; 　　} 　　} 　　} 　　alloc2->next=NULL; 　　status=0; 　　printf("请输入最大需求矩阵:\n"); 　　for(i=0;i<row;i++) 　　{ 　　for (j=0;jnext=maxium2->next=NULL; 　　scanf("%d",&maxium1->value); 　　status++; 　　} 　　else 　　{ 　　maxium2=(struct max *)malloc(maxlen); 　　scanf("%d,%d",&maxium2->value); 　　if(status==1) 　　{ 　　maxhead->next=maxium2; 　　status++; 　　} 　　maxium1->next=maxium2; 　　maxium1=maxium2; 　　} 　　} 　　} 　　maxium2->next=NULL; 　　status=0; 　　printf("请输入现时系统剩余的资源矩阵:\n"); 　　for (j=0;jnext=available2->next=NULL; 　　work1->next=work2->next=NULL; 　　scanf("%d",&available1->value); 　　work1->value=available1->value; 　　status++; 　　} 　　else 　　{ 　　available2=(struct available*)malloc(avalen); 　　work2=(struct available*)malloc(avalen); 　　scanf("%d,%d",&available2->value); 　　work2->value=available2->value; 　　if(status==1) 　　{ 　　avahead->next=available2; 　　workhead->next=work2; 　　status++; 　　} 　　available1->next=available2; 　　available1=available2; 　　work1->next=work2; 　　work1=work2; 　　} 　　} 　　available2->next=NULL; 　　work2->next=NULL; 　　status=0; 　　alloctemp=allochead; 　　maxtemp=maxhead; 　　for(i=0;i<row;i++) 　　for (j=0;jnext=need2->next=NULL; 　　need1->value=maxtemp->value-alloctemp->value; 　　status++; 　　} 　　else 　　{ 　　need2=(struct need *)malloc(needlen); 　　need2->value=(maxtemp->value)-(alloctemp->value); 　　if(status==1) 　　{ 　　needhead->next=need2; 　　status++; 　　} 　　need1->next=need2; 　　need1=need2; 　　} 　　maxtemp=maxtemp->next; 　　alloctemp=alloctemp->next; 　　} 　　need2->next=NULL; 　　status=0; 　　for(i=0;inext=finish2->next=NULL; 　　finish1->stat=0; 　　status++; 　　} 　　else 　　{ 　　finish2=(struct finish*)malloc(finilen); 　　finish2->stat=0; 　　if(status==1) 　　{ 　　finihead->next=finish2; 　　status++; 　　} 　　finish1->next=finish2; 　　finish1=finish2; 　　} 　　} 　　finish2->next=NULL; /*Initialization compleated*/ 　　status=0; 　　processtest=0; 　　for(temp=0;temp<row;temp++) 　　{ 　　alloctemp=allochead; 　　needtemp=needhead; 　　finishtemp=finihead; 　　worktemp=workhead; 　　for(i=0;istat==0) 　　{ 　　for(j=0;jnext,worktemp=worktemp->next) 　　if(needtemp->valuevalue) 　　processtest++; 　　if(processtest==colum) 　　{ 　　for(j=0;jvalue+=alloctemp->value; 　　worktemp1=worktemp1->next; 　　alloctemp=alloctemp->next; 　　} 　　if(status==0) 　　{ 　　pathhead=path1=path2=(struct path*)malloc(pathlen); 　　path1->next=path2->next=NULL; 　　path1->value=i; 　　status++; 　　} 　　else 　　{ 　　path2=(struct path*)malloc(pathlen); 　　path2->value=i; 　　if(status==1) 　　{ 　　pathhead->next=path2; 　　status++; 　　} 　　path1->next=path2; 　　path1=path2; 　　} 　　finishtemp->stat=1; 　　} 　　else 　　{ 　　for(t=0;tnext; 　　finishtemp->stat=0; 　　} 　　} 　　else 　　for(t=0;tnext; 　　alloctemp=alloctemp->next; 　　} 　　processtest=0; 　　worktemp=workhead; 　　finishtemp=finishtemp->next; 　　} 　　} 　　path2->next=NULL; 　　finishtemp=finihead; 　　for(temp=0;tempstat==0) 　　{ 　　printf("\n系统处于非安全状态!\n"); 　　exit(0); 　　} 　　finishtemp=finishtemp->next; 　　} 　　printf("\n系统处于安全状态.\n"); 　　printf("\n安全序列为: \n"); 　　do 　　{ 　　printf("p%d ",pathhead->value); 　　} 　　while(pathhead=pathhead->next); 　　printf("\n"); 　　return 0; 　　} #include "string.h" #include #include #define M 5 #define N 3 #define FALSE 0 #define TRUE 1 /*M个进程对N类资源最大资源需求量*/ int MAX[M][N]={{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}}; /*系统可用资源数*/ int AVAILABLE[N]={10,5,7}; /*M个进程对N类资源最大资源需求量*/ int ALLOCATION[M][N]={{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0}}; /*M个进程已经得到N类资源的资源量 */ int NEED[M][N]={{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}}; /*M个进程还需要N类资源的资源量*/ int Request[N]={0,0,0}; void main() { int i=0,j=0; char flag='Y'; void showdata(); void changdata(int); void rstordata(int); int chkerr(int); showdata(); while(flag=='Y'||flag=='y') { i=-1; while(i=M) { printf("请输入需申请资源的进程号（从0到"); printf("%d",M-1); printf("，否则重输入!）:"); scanf("%d",&i); if(i=M)printf("输入的进程号不存在，重新输入!\n"); } printf("请输入进程"); printf("%d",i); printf("申请的资源数\n"); for (j=0;jNEED[i][j]) { printf("进程"); printf("%d",i); printf("申请的资源数大于进程"); printf("%d",i); printf("还需要"); printf("%d",j); printf("类资源的资源量!申请不合理，出错!请重新选择!\n"); /*printf("申请不合理，出错!请重新选择!\n");*/ flag='N'; break; } else { if(Request[j]>AVAILABLE[j]) { printf("进程"); printf("%d",i); printf("申请的资源数大于系统可用"); printf("%d",j); printf("类资源的资源量!申请不合理，出错!请重新选择!\n"); /*printf("申请不合理，出错!请重新选择!\n");*/ flag='N'; break; } } } if(flag=='Y'||flag=='y') { changdata(i); if(chkerr(i)) { rstordata(i); showdata(); } else showdata(); } else showdata(); printf("\n"); printf("是否继续银行家算法演示,按'Y'或'y'键继续,按'N'或'n'键退出演示: "); scanf("%c",&flag); } } void showdata() { int i,j; printf("系统可用的资源数为:\n"); printf(" "); for (j=0;j<N;j++){ printf(" 资源"); printf("%d",j); printf(":"); printf("%d",AVAILABLE[j]); /*printf("\n");*/ /* cout<<endl; // cout<<"各进程资源的最大需求量:"<<endl<<endl; // for (i=0;i<M;i++) // { // cout<<"进程"<<i<<":"; // for (j=0;j<N;j++)cout<<" 资源"<<j<<": "<<MAX[i][j]; // cout<<endl; */ } printf("\n"); printf("各进程还需要的资源量:\n"); for (i=0;i<M;i++) { printf(" 进程"); printf("%d",i); printf(":"); for (j=0;j<N;j++){ printf("资源"); printf("%d",j); printf(":"); printf("%d",NEED[i][j]); /*printf("\n");*/ } printf("\n"); } printf("各进程已经得到的资源量: \n"); for (i=0;i<M;i++) { printf(" 进程"); printf("%d",i); /*printf(":\n");*/ for (j=0;j<N;j++){ printf("资源"); printf("%d",j); printf(":"); printf("%d",ALLOCATION[i][j]); /*printf("\n");*/ } printf("\n"); } } void changdata(int k) { int j; for (j=0;j<N;j++) { AVAILABLE[j]=AVAILABLE[j]-Request[j]; ALLOCATION[k][j]=ALLOCATION[k][j]+Request[j]; NEED[k][j]=NEED[k][j]-Request[j]; } }; void rstordata(int k) { int j; for (j=0;j<N;j++) { AVAILABLE[j]=AVAILABLE[j]+Request[j]; ALLOCATION[k][j]=ALLOCATION[k][j]-Request[j]; NEED[k][j]=NEED[k][j]+Request[j]; } }; int chkerr(int s) { int WORK,FINISH[M],temp[M]; int i,j,k=0; for(i=0;i<M;i++)FINISH[i]=FALSE; for(j=0;j<N;j++) { WORK=AVAILABLE[j]; i=s; while(i<M) { if (FINISH[i]==FALSE&&NEED[i][j]<=WORK) { WORK=WORK+ALLOCATION[i][j]; FINISH[i]=TRUE; temp[k]=i; k++; i=0; } else { i++; } } for(i=0;i<M;i++) if(FINISH[i]==FALSE) { printf("\n"); printf("系统不安全!!! 本次资源申请不成功!!!\n"); printf("\n"); return 1; } } printf("\n"); printf("经安全性检查，系统安全，本次分配成功。\n"); printf("\n"); printf(" 本次安全序列："); for(i=0;i"); } printf("\n"); return 0; }
银行家算法——C语言（11计科1班-孙鹏启——修正）
张同光 (Tongguang Zhang)：Hello everyone !
02-01 912
#define M 50 #include "stdio.h" int max[M][M], allocation[M][M], need[M][M], available[M];    /*定义全局变量 */ int i, j, n, m, r, t; void main() {     void check();     void print();     int p, q;
银行家算法C语言
入门C语言——杭电oj2016
10-25 3734
操作系统实验——银行家算法 相关数据结构: 可利用资源向量Available:这是一个含有m个元素的数组，其中的每一个元素代表一类可利用的资源数目，其初始值是系统中所配置的该类全部可用资源的数目，其数值随该类资源的分配和回收而动态地改变。如果Available［j］=K，则表示系统中现有Rj类资源K个。 最大需求矩阵Max: 这是一个n×m的矩阵，它定义了系统中n个进程中的每一个进程对m类资源的最...
银行家算法 c语言
04-16
已知进程{P0,P1,P2,P3,P4}，有三类系统资源A、B、C的数量分别为10、5、7，在T0时刻的资源分配情况如下图所示： （1）若进程P1请求资源，发出请求向量Request1（1，0，2），编写程序用银行家算法判断系统能否将资源分配给它； （2）若进程P2提出请求Request(0，1，0)，用银行家算法程序验证系统能否将资源分配给它。
银行家算法 c语言
mdjsmg的博客
04-16 3126
操作系统学习之银行家算法，c语言代码实现
《C语言程序设计》讲义
m0_63949551的博客
11-26 3089
《C语言程序设计》讲义 第一章 C语言概述 [教学目的] 介绍课程的性质、作用。通过本章的学习，使学生了解C语言的特点及C简单程序的构成，掌握C程序的编辑、编译、连接和运行的过程。 [教学内容] C语言特点，简单程序举例及上机步骤 重点：C程序基本结构及运行调试步骤 [教学方法] 多媒体 一、 C语言出现的背景 从计算机应用基础中学过计算机语言及语言处理系统，我们学习高级语言--C语言。 计算机：计算机是解决问题的电子工具、是由人来指挥的，人们为了用计算机来解决实际问题，...
红队系列-shellcode AV bypass Evasion免杀合集
aming小老弟
11-13 1427
壳就是软件所增加的保护，并不会破坏里面的程序结构，当我们运行这个加壳的程序时，系统首先会运行程序里的壳，然后由壳将加密的程序逐步还原到内存中，最后运行程序。加壳虽然对于特征码绕过有非常好的效果，加密壳基本上可以把特征码全部掩盖，但是缺点也非常的明显，因为壳自己也有特征，主流的壳如VMP, Themida等等。客户端上传特征，在云端无法检测到，则上传文件，文件通过杀软系统进行评判，得出总评分，对于无结果的，进行鉴定系统评分，总共得出结果返回给用户，并入云端库。比如可以远程读取png中的shellcode。
c++ 八股文问题总结
最新发布
ershiyidian的博客
07-01 605
C++中的重载和重写都是实现多态性的重要手段，但它们的侧重点和应用场景有所不同。重载主要是在同一个作用域内，提供多个同名函数的不同版本，以满足不同的参数需求或返回类型需求。重写则是在派生类中，提供对基类虚方法的定制化实现，以实现多态性和接口实现。在实际编程中，重载和重写都有广泛的应用。重载使得代码更加简洁和易于理解，因为它允许使用相同的函数名来处理不同的数据类型或数据数量。重写则允许派生类根据自身的需求来定制基类的方法行为，从而实现更加灵活和可扩展的程序设计。
银行家算法（c语言代码）
12-29
这是我参考了很多的同类代码后，自己写的一个实现银行家算法以及随机分配算法的c语言代码。这个代码符合操作系统课程设计有关银行家算法的实现。这是我的老师验收之后，并且修改过后的代码。欢迎大家下载。这个代码简单易懂，不复杂，适合大多数人使用。代码内注释较详细，更加方便读懂程序。
C语言银行家算法
05-10
操作系统银行家算法C语言代码，银行家算法的所有代码
基于C++的银行家算法模拟实现
05-04
设计要求 使用C++设计一个n 个并发进程共享m 个系统资源的系统。其中进程可动态申请资源和释放资源，系统按各进程的申请动态的分配资源，要求采用银行家算法实现。 设计思想 本实验是基于Dijkstra的银行家算法的实现，该算法可用于在操作系统中避免死锁。 该算法的基本思想是：让用户输入进程数与资源类数，并输入每个进程对每类资源的最大需求量，已占用数，以及系统中当前每类资源的可用数。再选择一个进程让其申请资源。当进程动态地申请资源时，系统必须首先确定是否有足够的资源分配给该进程。若有，系统将进一步计算在将这些资源分配给进程后，是否会使系统进入不安全状态，如果不会，系统才能将资源分配给它，否则系统让进程等待。 设计流程 本算法分为三步：初始状态安全性检查→银行家算法模拟分配进程→安全性检查。
用C语言编写的一个经典的，代码简洁的银行家算法模拟程序
05-13
代码简洁，思路清晰， 用C语言编写的一个经典的，代码简洁的银行家算法模拟程序
模拟银行家算法，用银行家算法实现资源分配
12-21
已知进程{P0,P1,P2,P3,P4}，有三类系统资源A、B、C的数量分别为10、5、7，在T0时刻的资源分配情况如下图所示： （1）若进程P1请求资源，发出请求向量Request1（1，0，2），编写程序用银行家算法判断系统能否将资源分配给它； （2）若进程P2提出请求Request(0，1，0)，用银行家算法程序验证系统能否将资源分配给它。
银行家算法C语言版
winneryy的博客
12-09 3527
#include <stdio.h> #include <stdlib.h> #include <conio.h> # define m 50 # define true 1 # define false 0 int no1; //进程数 int no2; //资源数 int r; int allocation[m][m],need[m][m],available[m],max[m][m]; char name1[m],name2[m]; .
c语言——银行家算法
weixin_44581918的博客
11-25 318
学习完操作系统的课程后，我迫不及待地进行了银行家算法的编写。其中银行家算法的编写只需3步； 话不多说，直接进入代码分析。 完整代码如下： #include<iostream> #include<assert.h> using namespace std; #define num_of_resource 3 #define num_of_binary 5 clas...
银行家算法(C语言实现)
weixin_45939614的博客
11-17 1020
添加链接描述 转载地址~~ #include<stdio.h> int Max[5][3] = {0,1,2,4,2,2,3,0,3,3,1,1,0,0,4}; //五个进程对各种资源的最大需求 int Allocation[5][3] = {0,1,0,2,0,0,3,0,3,2,1,1,0,0,2}; //五个进程已分配的各种资源数目 int Need[5][3] = {0,0,2,2,2,2,0,0,0,1,0,0,0,0,2}; //五个进程任需要各种资
银行家算法（C 语言实现）
Touch的博客
05-16 1125
这个程序局限性很大，只是为了熟悉一下银行家算法而已，所以随便写写罗。。。   #include&lt;stdio.h&gt; #define PROCESS_AMOUNT 5 //进程数量 #define RESOURCE_AMOUNT 3 //资源数量 //系统提供的各类资源的最大量 int Resoure_Max[3]={10,5,7}; //...
C语言入门：算法篇-程序设计基石
本资源是一份关于C语言编程的入门教程，着重讲解了第二章"算法-程序的灵魂"。该章节共包含五个关键部分： 1. 什么是算法：算法被定义为为解决问题而采取的方法和步骤，它强调了解决问题的不同策略。算法不仅需要...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值