① c語言銀行家演算法安全性判別
把1作為參數傳給yanzheng（） yanzheng（int m)
然後驗證函數里修改：
work=Avaliable;
i=m;
while(i<m)
{
if(Finish[i]==false&&Need[i]<=work)
{
work=work+Allocation[i];
Finish[i]=true;
anquan[k]=i;
k++;
i=0;
}
else
i++;
}
② c語言 設計一個銀行管理系統
功能：能夠輸入和查詢客戶存款取款記錄。在客戶文件中，每個客戶是一條記錄，包括編號、客戶姓名、支取密碼、客戶地址、客戶電話、賬戶總金額；在存取款文件中，每次存取款是一條記錄，包括編扮喚號、日期、類別、存取數目、經辦人。類別分為取款和存款兩種。本系統能夠輸入客戶存款或取款記錄；根據客戶姓名查詢存款和取款記錄。分步實施：1、初步完成總體設計，搭好框架，確定人機對話界面，確定函數個數；2、建立一個文件，輸入客戶的必要信息，能對文件進行顯示、輸入、修訂、刪除等。3、進一步要求：完成客戶姓名查詢存款和取款記錄，並能得到每次帳戶總金額。要求：1、用C語言實現系統；2、利用結構體數組實現信息的數據結構設計；3、系統的各個功能模塊要求用函數的形式實現；4、界面友好（良好的人機交互），程序加必要的注釋。課程設計實驗報告要求：1、預習報告：題目、課程設計任務、數廳純凱據結構、程序的總體設計（演算法）、模塊劃分 。2、實驗總結報告：流褲肢程圖、主要源程序代碼（需列印）、測試情況及調試中問題與解決方案、小結等要求：標明所用函數的用途和目的，簡單敘述製作思路。
是否可以解決您的問題？
③ 怎樣用C語言描述操作系統里的死鎖演算法謝謝。
利用銀行家演算法避免死鎖 . 銀行家演算法 設Requesti是進程Pi的請求向量，如果Requesti〔j〕=K，表示進程Pi需要K個Rj類型的資源。當Pi發出資源請求後，系統按下述步驟進行檢查：� (1) 如果Requesti〔j〕≤Need〔i,j〕，便轉向步驟2；否則認為出錯，因為它所需要的資源數已超過它所宣布的最大值。 (2) 如果Requesti〔j〕≤Available〔j〕，便轉向步驟(3)；否則， 表示尚無足夠資源，Pi須等待。 (3) 系統試探虛清著把資源分配給進程Pi，並修改下面數據結構中的數值：� Available〔j〕∶=Available〔j〕-Requesti〔j〕;� Allocation〔i,j〕∶=Allocation〔i,j〕+Requesti〔j〕;� Need〔i,j〕∶=Need〔i,j〕-Requesti〔j〕;� (4) 系統執行安全性演算法，檢查此次資源分配後，系統是否處於安全狀態。若安全，才正式將資源分配給進程Pi，以完成本次分配；否則， 將本次的試探分配作廢，恢復原來的資源分配狀態，讓進程Pi等待。 (3) 系統試探著把資源分配給進程Pi，並修改下面數據結構中的數值：� Available〔j〕∶=Available〔j〕-Requesti〔j〕;� Allocation〔i,j〕∶=Allocation〔i,j〕+Requesti〔j〕;� Need〔i,j〕∶=Need〔i,j〕-Requesti〔j〕;� (4) 系統執行安全性演算法，檢冊散查此次資源分配後，系統是否處於安全狀態。若安全，才正式將資源分配給進程Pi，以完成本次分配；否則， 將本次的試探分配作廢，恢復原來的資源分配狀態，讓進程Pi等待。 (3) 系統試探著把資源分配給進程Pi，並修改下面數據結構中的數值：� Available〔j〕∶=Available〔j〕-Requesti〔j〕;� Allocation〔i,j〕∶=Allocation〔i,j〕+Requesti〔j〕;� Need〔i,j〕∶=Need〔差姿前i,j〕-Requesti〔j〕;� (4) 系統執行安全性演算法，檢查此次資源分配後，系統是否處於安全狀態。若安全，才正式將資源分配給進程Pi，以完成本次分配；否則， 將本次的試探分配作廢，恢復原來的資源分配狀態，讓進程Pi等待。
④ 銀行家演算法 C語言編程
1.根據下面給出的系統中資源分配情況，以及各個進程的資源申請情況，通過銀行家演算法來判斷各進程的資源請求能否滿足（要求記錄程序的運行過程）。 已分配的
⑤ 銀行家演算法
#include<stdio.h>
#include "stdlib.h"
#define M 5
#define N 3
int max[M][N]={{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}};
int need[M][N]={{7,4,3},{1,2,2},{6,0,0},{0,1,1},{4,3,1}};
int allocation[M][N]={{0,1,0},{2,0,0},{3,0,2},{2,1,1},{0,0,2}};
int request[N]={0};
int finish[M]={0};
int available[N]={3,3,2};
int work[N]={3,3,2};
int safe[M]={0};
int n=1,m=1;
void showdata()
{
int i,j;
printf("系統可用的資源數為:\n");
for (j=0;j<N;j++)
printf("資源%c: %d \n",j+65, work[j]);
printf("\n");
printf("進程還需要的資源量: \n");
printf(" A B C\n" );
for(i=0;i<M;i++)
{
printf("進程p%d:",i);
for(j=0;j<N;j++)
printf(" %d ", need[i][j]);
printf("\n");
}
printf("進程已經得到的資源量:\n");
printf(" A B C\n" );
for(i=0;i<M;i++)
{
printf("進程%d:",i);
for(j=0;j<N;j++)
printf(" %d ",allocation[i][j]);
printf("\n"坦源);
}
}
void fp(int i){
for(int j=0;j<N;j++){
work[j]=work[j]+allocation[i][j];
finish[i]=1;
}
}
void secure(){
showdata();
int y=0,flag=6,h,i,j;
while(flag){
for(i=0;i<M;i++){
for(j=0;j<N;j++){
if((finish[i]==0)&&(need[i][j]<=work[j]))
continue;
else
j=15;
}
if(j==N){
fp(i);
safe[y++]=i;
i=15;
}
else
continue;
}
flag--;
}
for( h=0;h<M;h++){
if(finish[h]==1)
continue;
else
h=M+1;
}
if(h==M){
printf("該狀態安全！安全序列鏈碧是:\n");
for(int l=0;l<M;l++){
if(l==M-1)
printf("p%d",safe[l]);
else
printf("p%d-->",safe[l]);
}
n=1;
}
else
{
n=0;
printf("該狀態不安全！！");
}
}
void sfp(int k){
for(int i=0;i<N;i++){
work[i]=work[i]-request[i];
allocation[k][i]+=request[i];
need[k][i]-=request[i];
}
secure();
if(n==1){
printf("給與分配！\n");
}
else if(n==0){
printf("不給與分配！\n");
}
}
int choice(int k){
int e=1;
printf("輸入選擇的量:\n"讓喚態);
while(e){
for(int i=0;i<N;i++){
printf("資源%c:",65+i);
scanf("%d",&request[i]);
}
for(int j=0;j<N;j++){
if((request[j]<=need[k][j])&&(request[j]<=work[j]))
continue;
else{
printf("資源%c申請超量！不與分配!",65+j);
return 0;
e=0;
}
}
if(j==N){
printf("可以試申請！\n");
return 1;
e=0;
}
}
}
void recover(int k){
for(int i=0;i<N;i++){
work[i]=available[i];
need[k][i]+=request[i];
allocation[k][i]-=request[i];
}
}
void main(){
int p=1,k=1,i=0,c,f;
while(k){
printf("請選擇：1:顯示進程情況；2:判斷此時狀態是否安全；3:選擇進程進行申請資源；4：結束程序！");
scanf("%d",&c);
switch(c){
case 1:showdata();break;
case 2:secure();work[0]=3;for(i=0;i<N;i++) work[i]=available[i];
break;
case 3: for(i=0;i<M;i++)
finish[i]=0;
printf("請選擇進程（0--4）:\n");
scanf("%d",&f);
if(choice(f)){
sfp(f);
recover(f);
}
else{
printf("不與分配");
}
break;
case 4:k=0;
break;
default:k=0;break;
}
printf("\n");
}
}
⑥ 銀行家演算法得出的安全序列有順序嗎如{ p3，p0，p4 ，p2， p1}和{ p3，p0，p4 ，p1， p2}是一樣的嗎
不一樣
銀行家演算法假定前提如下：
p0 ~ p 4 各掌握有銀行家的若干資源，但要求完成他們的目標，分別還需要請求若干資源。
現在，銀行叢做塌家已經付出很多資源，手裡資源不多。而pX 們另外需求的資源也是大小不一的。
而一旦銀行家所有資源支出後，pX中仍然沒有誰完成任務，這就死鎖了（每個進程都把握一部分資源，並還在要資源，而資源已經木有了）
==========================
現在，演算法得出這樣一條順序，先優先供應滲圓p3,等p3完成他的線程後，p3會釋放所佔有的資源。銀行家（系統）利用p3所有的資源和自己手裡剩餘的資源按順序供應p0，p4 等等。
現在假定 供應完 p4後，銀行家手中握有資源 10單位
p1 總共需要胡胡20單位才能完成他的進程，而p1手中現有5單元
p2 總共需要10單位才能完成他的進程，而p2手中已經有了8單元了
請問，系統應該先供應哪個線程？
答案必然是先p2再p1
因為使用2資源供應完p2（10單位才能完成，已有8單位，還要2單位）,p2完成任務後，釋放所有資源，系統累計資源才有 10 - 2 + 10 = 18 單位的資源 ，才能滿足p1 的 15( = 20 -5 ）單位資源的請求。
而若反之， 所有資源投入p1 , p1 完成進度 15 / 20 p2 完成進度 8 / 10 這就徹底死了
所以 xxxxx p2 p1 能活， xxxxx p1 p2 會死
特別說明的是，銀行家演算法可以得到不止一條安全順序。能被銀行家證明可行的演算法都是死不了的演算法
⑦ 操作系統：實驗三 進程的死鎖與飢餓實驗報告
實驗三 進程的死鎖與飢餓實驗報告
一、單項選擇題（共5題，每題10分，共50分）
1、採用資源剝奪法可以解除死鎖，還可以採用_B___方法解除死鎖。
A.執行並行操作 B.撤銷進程
C.拒絕分配新資源 D.修改信號量
2、產生死鎖的四個必要條件是：互斥、_B___、循環等待、不剝奪。
A. 請求與阻塞 B.請求與保持
C.請求與釋放 D.釋放與阻塞
3、銀行家演算法在解決死鎖問題中是用於_B___的。
A. 預防死鎖 B.避免死鎖 C. 檢測死鎖 D.解除死鎖
4、在下列解決死鎖的方法中，屬於死鎖預防策略的是__B__。 A.銀行家演算法 B.資源有序分配法
C.死鎖檢測法 D.資源分配圖化簡法
5、某系統中有3個並發進程，都需要同類資源4個，試問該系統不會發生死鎖的最少資源數是_B___。
A.9 B.10 C.11 D.12
二、填空題（共4題，每題5分，共20分）
1、在有M個進程的系統中出現死鎖時，死鎖進程的個數K應該滿足的條件是_2=<k<=m___。
2、死鎖產生的4個必要條件是：互斥條件、_請求和保持條件___、_不剝奪條件___和_環路等待條件___。
3、產生死鎖的根本原因是_可共享資源不足___，另一個基本原因是_進程的推進順序不當___。
4、銀行間演算法中，當一個進程提出的資源請求將導致系統從_安全狀態___進入_不安全狀態___時，系統就拒絕它的資源請求
三、 簡答題（共2題，每題15分，共30分） 1、按序分配是預防死鎖的一種策略。什麼是按序分配？為什麼按序分配可以預防死鎖？
按序分配是將系統中所有資源按類型進行 線性排隊，並賦予不同的編號，規定所有進程對資源的請求必須嚴格按照資源序號遞增的次序提出。 按序分配可破壞產生死鎖的四個必要條件中的「循環等待條件」
2、產生死鎖的必要條件是什麼？解決死鎖問題常採用哪幾種措施？
必要條件：互斥條件、部分分配條件、剝奪條件、環路條件。
解決死鎖問題採用的措施：
(1)撤銷進程法：採用撤銷進程法時，可用兩種形式來撤銷進程。一種是撤銷所有捲入死鎖的進程。另一種是一次撤銷一個進程直到死鎖消失。
⑧ 用C語言或C++編寫操作系統作業：銀行家演算法
免死鎖的演算法。
要解釋銀行家演算法，必須先解釋操作系統安全狀態和不安全狀態。
安全狀態：如果存在一個由系統中所有進程構成的安全序列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;i<row;i++)
{
for (j=0;j<colum;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;i<row;i++)
{
for (j=0;j<colum;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;j<colum;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;i<row;i++)
for (j=0;j<colum;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;i<row;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;temp<row;temp++)
{
alloctemp=allochead;
needtemp=needhead;
finishtemp=finihead;
worktemp=workhead;
for(i=0;i<row;i++)
{
worktemp1=worktemp;
if(finishtemp->stat==0)
{
for(j=0;j<colum;j++,needtemp=needtemp->next,worktemp=worktemp->next)
if(needtemp->value<=worktemp->value)
processtest++;
if(processtest==colum)
{
for(j=0;j<colum;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;t<colum;t++)
alloctemp=alloctemp->next;
finishtemp->stat=0;
}
}
else
for(t=0;t<colum;t++)
{
needtemp=needtemp->next;
alloctemp=alloctemp->next;
}
processtest=0;
worktemp=workhead;
finishtemp=finishtemp->next;
}
}
path2->next=NULL;
finishtemp=finihead;
for(temp=0;temp<row;temp++)
{
if(finishtemp->stat==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;
}
另外,虛機團上產品團購,超級便宜
⑨ 銀行家演算法C++描述
#include <iostream>
#include <string>
#define M 3 //資源的種類數
#define N 5 //進程的個數
void output(int iMax[N][M],int iAllocation[N][M],int iNeed[N][M],int iAvailable[M],char cName[N]); //統一的輸出格式
bool safety(int iAllocation[N][M],int iNeed[N][M],int iAvailable[M],char cName[N]);
bool banker(int iAllocation[N][M],int iNeed[N][M],int iAvailable[M],char cName[N]);
int main()
{
int i,j;
//當前可用每類資源的資源數
int iAvailable[M]={3,3,2};
//系統中N個進程中的每一個進程對M類資源的最大需求
int iMax[N][M]={{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}};
//iNeed[N][M]每一個進程尚需的各類資源數
//iAllocation[N][M]為系統中每一類資源當前已分配給每一進程的資源數
int iNeed[N][M],iAllocation[N][M]={{0,1,1},{2,0,0},{3,0,2},{2,1,1},{0,0,2}};
//進程名
char cName[N]={'a','b','c','d','e'};
bool bExitFlag=true; //退出標記
char ch; //接收選擇是否繼續提出申請時傳進來的值
bool bSafe; //存放安全與否的標志
//計算iNeed[N][M]的值
for(i=0;i<N;i++)
for(j=0;j<M;j++)
iNeed[i][j]=iMax[i][j]-iAllocation[i][j];
//輸出初始值
output(iMax,iAllocation,iNeed,iAvailable,cName);
//判斷當前狀態是否安全
bSafe=safety(iAllocation,iNeed,iAvailable,cName);
//是否繼續提出申請
while(bExitFlag)
{
cout<<"\n"<<"繼續提出申請？\ny為是；n為否。\n";
cin>>ch;
switch(ch)
{
case 'y':
//cout<<"調用銀行家演算法";
bSafe=banker(iAllocation,iNeed,iAvailable,cName);
if (bSafe) //安全，則輸出變化後的數據
output(iMax,iAllocation,iNeed,iAvailable,cName);
break;
case 'n':
cout<<"退出。\n";
bExitFlag=false;
break;
default:
cout<<"輸入有誤，請重新輸入：\n";
}
}
}
//輸出
void output(int iMax[N][M],int iAllocation[N][M],int iNeed[N][M],int iAvailable[M],char cName[N])
{
int i,j;
cout<<"\n\t Max \tAllocation\t Need \t Available"<<endl;
cout<<"\tA B C\tA B C\tA B C\t A B C"<<endl;
for(i=0;i<N;i++)
{
cout<<cName[i]<<"\t";
for(j=0;j<M;j++)
cout<<iMax[i][j]<<" ";
cout<<"\t";
for(j=0;j<M;j++)
cout<<iAllocation[i][j]<<" ";
cout<<"\t";
for(j=0;j<M;j++)
cout<<iNeed[i][j]<<" ";
cout<<"\t";
cout<<" ";
//Available只需要輸出一次
if (i==0)
for(j=0;j<M;j++)
cout<<iAvailable[j]<<" ";
cout<<endl;
}
}
//安全性演算法，進行安全性檢查；安全返回true，並且輸出安全序列，不安全返回false，並輸出不安全的提示；
bool safety(int iAllocation[N][M],int iNeed[N][M],int iAvailable[M],char cName[N])
{
}
//定位ch對應的進程名在數組中的位置
//沒找見返回－1，否則返回數組下標
int locate(char cName[N],char ch)
{
int i;
for(i=0;i<N;i++)
if (cName[i]==ch) //找到
return i;
//未找到
return -1;
}
//提出申請,返回提出申請的進程名對應的下標
int request(char cName[N],int iRequest[M])
{
int i,loc;
char ch;
bool bFlag=true;
//判斷輸入的進程名是否有誤
while(bFlag)
{
//輸出進程名
for(i=0;i<N;i++)
cout<<cName[i]<<"\t";
//輸入提出申請的進程名
cout<<"\n輸入提出資源申請的進程名：\n";
cin>>ch;
//定位ch對應的進程名在進程名數組中的位置
loc=locate(cName,ch);
//沒找到，重新輸入
if (loc==-1)
cout<<"\n您輸入的進程名有誤！請重新輸入";
//找到，退出循環
else
bFlag=false;
}
//輸入提出申請的資源數
cout<<"輸入申請各類資源的數量：\n";
for(i=0;i<M;i++)
cin>>iRequest[i];
//返回提出申請的進程名對應的下標
return loc;
}
bool banker(int iAllocation[N][M],int iNeed[N][M],int iAvailable[M],char cName[N])
{
}
這個是c++的 我的報告
⑩ 求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)