c语言实现银行家算法下载,银行家算法c#

本文目录一览：

1、求一个银行家算法c语言模拟，能运行的，谢谢。
2、c语言银行家算法安全性判别
3、求n个数的全排列，n不定。用c语言。用于银行家算法中求安全序列
4、银行家算法的C语言程序
5、急！银行家算法用C语言编写．全部程序．
6、c程序调用函数出错,关于sprintf

求一个银行家算法c语言模拟，能运行的，谢谢。

在什么地方运行（即运行环境是什么），用什么语言写，要达到什么功能，你要说清楚

c语言银行家算法安全性判别

把1作为参数传给yanzheng（） yanzheng（int m)

然后验证函数里修改：

work=Avaliable;

i=m;

while(im)

{

if (Finish[i]==falseNeed[i]=work)

{

work=work+Allocation[i];

Finish[i]=true;

anquan[k]=i;

k++;

i = 0;

}

else

i++;

}

求n个数的全排列，n不定。用c语言。用于银行家算法中求安全序列

好久没用c了，所以代码可能要用到伪代码

先定义a[maxn]

用子函数递归

void p(int x)

{

if (n == x+1)

{

//foreach a print

//输出数组a

}

for (int i=1 to n)

{

a[x] = i;

p(x+1);

a[x] = 0;

}

主函数main调用p(n)

银行家算法的C语言程序

1.根据下面给出的系统中资源分配情况，以及各个进程的资源申请情况，通过银行家算法来判断各进程的资源请求能否满足（要求记录程序的运行过程）。已分配的

急！银行家算法用C语言编写．全部程序．

银行家算法

银行家算法是一种最有代表性的避免死锁的算法。

要解释银行家算法，必须先解释操作系统安全状态和不安全状态。

安全状态：如果存在一个由系统中所有进程构成的安全序列P1，…，Pn，则系统处于安全状态。安全状态一定是没有死锁发生。

不安全状态:不存在一个安全序列。不安全状态不一定导致死锁。

那么什么是安全序列呢？

安全序列：一个进程序列{P1，…，Pn}是安全的，如果对于每一个进程Pi(1≤i≤n），它以后尚需要的资源量不超过系统当前剩余资源量与所有进程Pj (j i )当前占有资源量之和。

银行家算法：

我们可以把操作系统看作是银行家，操作系统管理的资源相当于银行家管理的资金，进程向操作系统请求分配资源相当于用户向银行家贷款。操作系统按照银行家制定的规则为进程分配资源，当进程首次申请资源时，要测试该进程对资源的最大需求量，如果系统现存的资源可以满足它的最大需求量则按当前的申请量分配资源，否则就推迟分配。当进程在执行中继续申请资源时，先测试该进程已占用的资源数与本次申请的资源数之和是否超过了该进程对资源的最大需求量。若超过则拒绝分配资源，若没有超过则再测试系统现存的资源能否满足该进程尚需的最大资源量，若能满足则按当前的申请量分配资源，否则也要推迟分配。

算法：

n：系统中进程的总数

m：资源类总数

Available: ARRAY[1..m] of integer;

Max: ARRAY[1..n,1..m] of integer;

Allocation: ARRAY[1..n,1..m] of integer;

Need: ARRAY[1..n,1..m] of integer;

Request: ARRAY[1..n,1..m] of integer;

符号说明：

Available 可用剩余资源

Max 最大需求

Allocation 已分配资源

Need 需求资源

Request 请求资源

当进程pi提出资源申请时，系统执行下列

步骤：(“=”为赋值符号，“==”为等号)

step（1）若Request=Need, goto step（2）；否则错误返回

step（2）若Request=Available, goto step（3）；否则进程等待

step（3）假设系统分配了资源，则有：

Available=Available-Request;

Allocation=Allocation+Request;

Need=Need-Request

若系统新状态是安全的，则分配完成

若系统新状态是不安全的，则恢复原状态，进程等待

为进行安全性检查，定义数据结构：

Work:ARRAY[1..m] of integer;

Finish:ARRAY[1..n] of Boolean;

安全性检查的步骤：

step (1):

Work=Available;

Finish=false;

step (2) 寻找满足条件的i：

a.Finish==false;

b.Need=Work;

如果不存在，goto step(4)

step(3)

Work=Work+Allocation;

Finish=true;

goto step(2)

step (4) 若对所有i,Finish=true,则系统处于安全状态，否则处于不安全状态

/* 银行家算法，操作系统概念(OS concepts Six Edition)

reedit by Johnny hagen，SCAU，run at vc6.0

#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;irow;i++)

{

for (j=0;jcolum;j++)

{

printf(“请输入已分配给进程 p%d 的 %c 种系统资源:”,i,’A’+j);

if(status==0)

{

allochead=alloc1=alloc2=(struct allocation*)malloc(alloclen);

alloc1-next=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;irow;i++)

{

for (j=0;jcolum;j++)

{

printf(“请输入进程 p%d 种类 %c 系统资源最大需求:”,i,’A’+j);

if(status==0)

{

maxhead=maxium1=maxium2=(struct max*)malloc(maxlen);

maxium1-next=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;jcolum;j++)

{

printf(“种类 %c 的系统资源剩余:”,’A’+j);

if(status==0)

{

avahead=available1=available2=(struct available*)malloc(avalen);

workhead=work1=work2=(struct available*)malloc(avalen);

available1-next=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;irow;i++)

for (j=0;jcolum;j++)

{

if(status==0)

{

needhead=need1=need2=(struct need*)malloc(needlen);

need1-next=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;irow;i++)

{

if(status==0)

{

finihead=finish1=finish2=(struct finish*)malloc(finilen);

finish1-next=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;temprow;temp++)

{

alloctemp=allochead;

needtemp=needhead;

finishtemp=finihead;

worktemp=workhead;

for(i=0;irow;i++)

{

worktemp1=worktemp;

if(finishtemp-stat==0)

{

for(j=0;jcolum;j++,needtemp=needtemp-next,worktemp=worktemp-next)

if(needtemp-value=worktemp-value)

processtest++;

if(processtest==colum)

{

for(j=0;jcolum;j++)

{

worktemp1-value+=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;tcolum;t++)

alloctemp=alloctemp-next;

finishtemp-stat=0;

}

else

for(t=0;tcolum;t++)

{

needtemp=needtemp-next;

alloctemp=alloctemp-next;

}

processtest=0;

worktemp=workhead;

finishtemp=finishtemp-next;

}

path2-next=NULL;

finishtemp=finihead;

for(temp=0;temprow;temp++)

{

if(finishtemp-stat==0)

{

printf(“\n系统处于非安全状态!\n”);

exit(0);

}

finishtemp=finishtemp-next;

}

printf(“\n系统处于安全状态.\n”);

printf(“\n安全序列为: \n”);

{

printf(“p%d “,pathhead-value);

}

while(pathhead=pathhead-next);

printf(“\n”);

return 0;

}

c程序调用函数出错,关于sprintf

你用了sprintf后只是格式化了

字符串

，想要在终端输出还是要printf那个格式化后的字符串的。

原创文章，作者：小蓝，如若转载，请注明出处：https://www.506064.com/n/154170.html

c语言实现银行家算法下载,银行家算法c#

本文目录一览：

求一个银行家算法c语言模拟，能运行的，谢谢。

c语言银行家算法安全性判别

求n个数的全排列，n不定。用c语言。用于银行家算法中求安全序列

银行家算法的C语言程序

急！银行家算法用C语言编写．全部程序．

c程序调用函数出错,关于sprintf

相关推荐

发表回复