銀行家演算法c語言
Ⅰ 求一個在c語言環境下進行死鎖檢測的程序
#include<stdio.h>
#include<iostream.h>
#include<string.h>
const int MAXQUEUE=100; //定義表的最大行數
typedef struct node{
int resource;
int process;
}cell;
cell occupy[MAXQUEUE];
int occupy_quantity;
cell wait[MAXQUEUE];
int wait_quantity;
//初始化函數
void initial()
{
int i;
for(i=0;i<MAXQUEUE;i++){
occupy.process=-1;
occupy.resource=-1;
wait.process=-1;
wait.resource=-1;
}
occupy_quantity=0;
wait_quantity=0;
}
//讀數據文件
int readData()
{
FILE *fp;
char fname[20];
int i;
cout<<"請輸入資源分配表文件的文件名:"<<endl;
strcpy(fname,"10trouble1.txt");
//cin>>fname;
if((fp=fopen(fname,"r"))==NULL){
cout<<"錯誤,文件打不開,請檢查文件名:)"<<endl;
return 0;
}
else{
while(!feof(fp)){
fscanf(fp,"%d %d",&occupy[occupy_quantity].resource,&occupy[occupy_quantity].process);
occupy_quantity++;
}
}
cout<<"請輸入進程等待表文件的文件名:"<<endl;
strcpy(fname,"10trouble2.txt");
//cin>>fname;
if((fp=fopen(fname,"r"))==NULL){
cout<<"錯誤,文件打不開,請檢查文件名:)"<<endl;
return 0;
}
else{
while(!feof(fp)){
fscanf(fp,"%d %d",&wait[wait_quantity].process,&wait[wait_quantity].resource);
wait_quantity++;
}
}
//輸出所讀入的數據
cout<<endl<<endl<<"輸出所讀入的數據"<<endl;
cout<<"━━━━━━━━━━━━━━━━━━━━━━━"<<endl;
cout<<"資源分配表"<<endl;
cout<<"資源編號 進程編號"<<endl;
for(i=0;i<occupy_quantity;i++){
cout<<" "<<occupy.resource<<" "<<occupy.process<<endl;
}
cout<<"———————————————————————"<<endl;
cout<<"進程等待表"<<endl;
cout<<"進程編號 資源編號"<<endl;
for(i=0;i<wait_quantity;i++){
cout<<" "<<wait.resource<<" "<<wait.process<<endl;
}
return 1;
}
//檢測
void check()
{
int table[MAXQUEUE][MAXQUEUE];
int table1[MAXQUEUE][MAXQUEUE];
int i,j,k;
int flag,t,p;
int max_process;
//初始化表格
for(i=0;i<MAXQUEUE;i++){
for(j=0;j<MAXQUEUE;j++){
table[j]=0;
table1[j]=0;
}
}
//先找到進程最大編號
max_process=-1;
for(i=0;i<occupy_quantity;i++){
if(occupy.process>max_process){
max_process=occupy.process;
}
}
for(i=0;i<wait_quantity;i++){
if(wait.process>max_process){
max_process=wait.process;
}
}
for(i=0;i<wait_quantity;i++){
for(j=0;j<occupy_quantity;j++){
if(wait.resource==occupy[j].resource){
table[wait.process][occupy[j].process]=1;
table1[wait.process][occupy[j].process]=1;
}
}
}
cout<<"初始等待佔用表:"<<endl;
for(i=0;i<max_process+1;i++){
for(j=0;j<max_process+1;j++){
cout<<table[j]<<" ";
}
cout<<endl;
}
cout<<endl;
for(i=0;i<max_process+1;i++){
for(j=0;j<max_process+1;j++){
for(k=0;k<max_process+1;k++){
table[j]=table[j]||(table[k]&&table[k][j]);
}
}
}
cout<<"檢測後的等待佔用表:"<<endl;
for(i=0;i<max_process+1;i++){
for(j=0;j<max_process+1;j++){
cout<<table[j]<<" ";
}
cout<<endl;
}
flag=-1;
for(i=0;i<max_process+1;i++){
if(table==1){
flag=i;
break;
}
}
cout<<endl<<endl<<"檢測結果"<<endl;
cout<<"———————————————————"<<endl;
if(flag!=-1){
cout<<"存在死鎖"<<endl;
cout<<"進程循環等待隊列:";
p=flag; //存在進程循環等待隊列的那一進程
//進程循環等待隊列中的所有進程是table表中的這一行是1的進程,只是順序要再確定
t=1;
while(t){
cout<<p<<" ";
for(j=0;j<max_process+1;j++){
if(table1[p][j]==1){
if(table[j][flag]==1){
p=j;
break;
}
}
}
if(p==flag)t=0;
}
cout<<flag<<endl;
}
else{
cout<<"不存在死鎖"<<endl;
}
}
Ⅱ c#幾個數四捨五入累加後少了
生活中對於小數位多的情況下，會理所當然的應用四捨五入演算法進行數據小數位保留，比如保留小數點後兩位....
但是，有一種場景非常有趣，0.5按比例拆分成0.125和0.375之後，對拆分結果進行四捨五入後得到0.13和0.38，再加回去後發現結果變成了0.51....
這就是四捨五入的缺陷，簡而言之就是不公正，如何在程序上避免這種情況，首先引入一種演算法，叫銀行家演算法，即四捨六入五取偶....
什麼是銀行家演算法？
銀行家舍入法是由IEEE 754標准規定的浮點數取整演算法 [1] ，大部分的編程軟體都使用的是這種方法。 所謂銀行家舍入法，其實質是一種四捨六入五取偶（又稱四捨六入五留雙）法。其規則是：當基拍捨去位的數值小於5時，直接捨去該位；當捨去位的數值大於等於6時，在捨去該位的同時向前位進一；當捨去位的數值等於5且（5後不為空且非全0）時，在捨去該位的同時向前位進一；當捨去位的數值等於5且（5後為空或全0）時，如果前位數值為奇，則在舍搏備羨去滾輪該位的同時向前位進一，如果前位數值為偶，則直接捨去該位。
簡單的說，就是：四捨六入五考慮，五後非空就進一，五後為空看奇偶，五前為偶應捨去，五前為奇要進一
Ⅲ 銀行家演算法的C語言程序
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;
}
另外,虛機團上產品團購,超級便宜
Ⅳ 計算機408有多難
408的全稱是「408計算機專業基礎綜合」，是計算機專業/軟體工程等專業的統考科目。與其他統考科目不同，計算機408比絕大多數學校的自主命題都要難很多。
計算機專業基礎綜合考試，考試代碼是408，總共涉及四門專業課的考察，分別是數據結構、計算機組成原理、操作系統和計算機網路。
試卷內容結構：
數據結構 45分
計算機組成原理 45分
操作系統35分
計算機網路 25
對於408的難度，一個很明顯的事實就是，採用408作為考試科目的學校，分數線都不高（相對不高)。
但是，隨著普及，408難度的降低可能是一種趨勢，畢竟考研是一場選拔性考試，主要目的是篩選考生，而不是難倒考生。而重新歸來的408統考，可能也會爭取成為受眾更廣的統考科目。
23考研408復習建議：
計算機網路★★★
考試內容主要圍繞TCP/IP協議層次的具體展開，包括以下內容：物理層、數據鏈路層、網路層、傳輸層、應用層。
計算機網路這門課的特點是：在考研專業課中所佔分數最少，但是涉及到的具體的知識點最多。
考生復習時要注意按照層進行知識點的復習和總結。對於每一層，重點把握這一層的協議有哪些、引入這些協議的原因、涉及到哪些重要演算法、演算法的內容、每一層和上下層之間的關系、每一層用到的硬體設備及作用等，也就是說，學習完一層時一定要用系統的方法將具體的知識點串連在一起，不要局限於孤立地理解和掌握每個細節的知識點。
這四門專業課之間有一定的內在聯系，數據結構和組成原理是操作系統的先修課程，計算機網路相對來說比較獨立，或者說不需要先修課程。
內容的交叉有一些，主要表現在組成原理和操作系統這兩門專業課之間，二者都包含了存儲系統和輸入/輸出系統的內容，如：內存管理的各種頁面置換演算法、虛擬存儲器等。
如果不是跨專業考生，也就是說這些專業課以前都系統的學習過，那麼復習時可以不按順序。但如果是初學者，必須先學習完數據結構和組成原理後再學習操作系統，否則有些概念和原理難以理解。
四門課的復習時間應該合理分配，重點放在數據結構和組成原理上，尤其數據結構更要多花一些時間;操作系統和計算機網路的很多知識點需要在理解的基礎上進行記憶，相對來說容易一些。當然難易程度是相對的，具體情況也要因人而異，靈活安排。
Ⅵ 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語言描述操作系統里的死鎖演算法謝謝。
利用銀行家演算法避免死鎖 . 銀行家演算法 設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語言程序
曾經做過，可惜忘了
Ⅸ 求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)