实现银行家算法和先进先出算法_对文件读写数据

操作系统考试老师出了两道题，一个是先进先出，另一个是银行家算法，题目如下

1．请使用FCFS算法模拟进程调度。假设系统有n (n>=2) 个进程，给定进程的到达时间以及需要执行的时间长短，给出相应的执行顺序。数据以文件方式给出,文件名为data.fcfs,格式为:

文件共n(N1…Nn)行.

在Nn行中有三个数据,第n个进程的进程名,到达时间,执行时间

请根据给定数据，输出进程执行顺序到文件out.fcfs中。

输出共n行 : 根据进程执行顺序,每一行输出进程名,进程开始时间,结束时间三项(空格隔开)。

2 . 银行家算法是避免死锁的常用算法。假设系统有m（m>=2）种资源，n个并发进程。给定当前时刻进程-资源关系，对某个进程提出的资源请求，银行家算法判断是否可以满足该请求，如果能够满足，给出安全序列。
要求根据给定进程-资源关系模拟实现银行家算法，给出安全序列。 

给定进程-资源关系格式文件data.dijkstra: 

第一行为资源数m(m>=2).

第二行为并发进程数n(N1,N2,N3…Nn).

第三行代表可利用资源向量,有m个数,为m种资源每一个的可利用资源数(m1,m2,m3…)

之后有n(N1,N2,N3…Nn)行,每一行有一个进程名以及2*m个数，前m个代表Nn这个进程对m类资源的最大需求数, 后m个代表进程对m类资源的分配数.

最后一行为资源请求,共m+1个数,第一个数k代表进程Nk,后m个数代表进程Nk请求m种资源的数量。

请根据给定数据，输出进程Nk请求资源之后的安全序列到文件out.dijkstra中，若不满足安全状态则输出Failed。

输出格式 :  进程名N1 进程名N2 …  (中间用空格隔开)

1：第一道题的输入数据是这样子的

代码如下

#include<bits/stdc++.h>
#include<fstream>
using namespace std;
int main()
{
    int line=0;
    char a[100];//进程名称
    int start[100];//到达时间
    int time[100];//持续时间
    int len=0;
    ifstream fin("D:/data.fcfs");
    ofstream fout("D:/data1.fcfs");
    if(!fin || !fout){
        cout << "wrong" << endl;
    }
    while(fin){
        fin >> a[line] >> start[line] >> time[line];
        line++;

    }
    int array[line];
    memset(array,0,sizeof(array));
   for(int i=0;i<line-1;i++){//根据start数组得到从小到大的一种进程序号，先来先服务
        int min=1000;
        int tip=-1;
     for(int j=0;j<line-1;j++){
          if(start[j]<min && array[j]==0){
            min =start[j];
            tip=j;
          }
     }
      array[tip]=-1;
     if(i==0){
          fout<<a[tip] <<"	"<<start[tip] << "	" << start[tip]+time[tip] << "
";
          len=start[tip];
          len+=time[tip];
      }else{
        fout<<a[tip] <<"	"<<len << "	" << len+time[tip] << "
";
       len+=time[tip];
      }
   }
    fin.close();
    fout.close();
    return 0;
}

#include<bits/stdc++.h>
using namespace std;

int main()
{
    freopen("D:/data.fcfs","r",stdin);
    freopen("D:/data1.fcfs","w",stdout);
    int line=0;
    char a[100];
    int start[100];
    int time[100];
    int array[100];
    int len=0;
    memset(array,0,sizeof(array));
    for(int i=0;i<5;i++){
            cin >> a[i] >> start[i]  >> time[i];
    }
    for(int i=0;i<5;i++){
        int min=1000;
        int tip=-1;
        for(int j=0;j<5;j++){
            if(start[j]<min && array[j]==0){
                min=start[j];
                tip=j;
            }
        }
        array[tip]=-1;
        if(i==0){
           cout<<a[tip] <<"	"<<start[tip] << "	" << start[tip]+time[tip] << "
";
           len=start[tip];
           len+=time[tip];
       }else{
            if(len<start[tip]){
                len=start[tip];
                cout << len <<"  " << len+time[tip] <<"
";
                len+=time[tip];
            }else{
             cout<<a[tip] <<"	"<<len << "	" << len+time[tip] << "
";
             len+=time[tip];
            }
       }
    }
    return 0;
}

输出到文件data1.fcfs

2：第二道题数据如下

 

代码

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include<fstream>
#include<iostream>
using namespace std;
# define m 50
int no1;  //进程数
int no2;  //资源数
int r;
ofstream fout("D:\out.dijkstra");
int allocation[m][m],need[m][m],available[m],max1[m][m];
char name1[m],name2[m];
char d[5];
//={'A','B','C','D','E'}                         //定义全局变量
void check()   //安全算法函数
{
    int k,f,v=0,i,j;
    int work[m],a[m];
    bool finish[m];
    r=1;
    for(i=0;i<no1;i++)
        finish[i]=false;   // 初始化进程均没得到足够资源数并完成
    for(i=0;i<no2;i++)
        work[i]=available[i];//work[i]表示可提供进程继续运行的各类资源数
    k=no1;
    do{
        for(i=0;i<no1;i++)
        {
            if(finish[i]==false)
            {
                f=1;
                for(j=0;j<no2;j++)
                    if(need[i][j]>work[j])
                        f=0;
                    if(f==1)      //找到还没有完成且需求数小于可提供进程继续运行的资源数的进程
                    {
                        finish[i]=true;
                        a[v++]=i;   //记录安全序列号
                        for(j=0;j<no2;j++)
                            work[j]+=allocation[i][j];  //释放该进程已分配的资源
                    }
            }
        }
        k--;      //每完成一个进程分配，未完成的进程数就减1
    }while(k>0);
    f=1;
    for(i=0;i<no1;i++)    //判断是否所有的进程都完成
    {
        if(finish[i]==false)
        {   f=0;
            break;
        }
    }
    if(f==0)       //若有进程没完成，则为不安全状态
    {
        printf("系统处在不安全状态！");
        fout<<"Failed"<<endl;
        r=0;
    }
    else{
        printf("
系统当前为安全状态，安全序列为：
");
        for(i=0;i<no1;i++)
        {
            //printf("p%d  ",a[i]);  //输出安全序列
            cout<<d[a[i]]<<" ";
            fout<<d[a[i]]<<" ";
        }
           fout<<endl;
    }
}
void print()  //输出函数
{
    int i,j;
    printf("
");
    printf("*************此时刻资源分配情况*********************
");
    printf("进程名/号   |   Max     | Allocation   |    Need    |
");
    for (i = 0; i < no1; i++)
        {
            //printf("   p%d        ",i);
            cout<<"     "<<d[i]<<"        ";
             for (j = 0; j < no2; j++)
                {printf("%d   ",max1[i][j]);}

            for (j = 0; j < no2; j++)
                {printf(" %d   ",allocation[i][j]);}

            for (j = 0; j < no2; j++)
                {printf(" %d   ",need[i][j]);}

            printf("
");
        }
        printf("
");
        printf("各类资源可利用的资源数为:");
        for (j = 0; j < no2; j++)
            {printf(" %d",available[j]);}
        printf("
");
}
int main(void)
{
    void check();
    void print();
    int i,j,p=0,q=0;
    char c;
    //ofstream fout("D:\out.dijkstra",ios::out);
    ifstream fin("D:\data.dijkstra");
    int request[m],allocation1[m][m],need1[m][m],available1[m];
    printf("		**********************************************
");
    printf("		*           银行家算法的设计与实现           *
");
    printf("		**********************************************
");
    printf("请输入资源种类数:
");
    //scanf("%d",&no2);
    //fscanf(fin,"%d",&no2);
    fin>>no2;//3
    printf("请输入进程总数:
");
    //scanf("%d",&no1);
    //fscanf(fin,"%d",&no1);
    fin>>no1;//5
    printf("请输入Available矩阵
");
    for(i=0;i<no2;i++)
        fin>>available[i];
        //fscanf(fin,"%d",&available[i]);       //输入已知的可用资源数
    printf("请输入Max矩阵:
");
    printf("请输入Allocation矩阵:
");
    for(i=0;i<no1;i++)
    {
        fin>>d[i];
        for(j=0;j<2*no2;j++)
        {
            if(j<no2)
                fin>>max1[i][j];
            else
                fin>>allocation[i][j-3];
        }
    }
            //fscanf(fin,"%d",&max1[i][j]);
   //输入已知进程最大资源需求量
    /*printf("请输入Allocation矩阵:
");
    for(i=0;i<no1;i++)
        for(j=0;j<no2;j++)
            fin>>allocation[i][j];
            //fscanf(fin,"%d",&allocation[i][j]);  //输入已知的进程已分配的资源数*/
    for(i=0;i<no1;i++)
        for(j=0;j<no2;j++)
        need[i][j]=max1[i][j]-allocation[i][j]; //根据输入的两个数组计算出need矩阵的值

    print();  //输出已知条件
    check();  //检测T0时刻已知条件的安全状态

//    if(r==1)  //如果安全则执行以下代码
//    {
//        do{
//        q=0;
//        p=0;
//        printf("
请输入请求资源的进程号(0~4)：
");
//        for(j=0;j<=10;j++)
//        {
//            //fscanf(fin,"%d",&i);
//            fin>>i;
//            i--;
//            if(i>=no1)
//                {
//                printf("输入错误，请重新输入：
");
//                   continue;
//                }
//                else break;
//            }
//            printf("
请输入该进程所请求的资源数request[j]:
");
//            for(j=0;j<no2;j++)
//                //scanf("%d",&request[j]);
//                fin>>request[j];
//            for(j=0;j<no2;j++)
//                if(request[j]>need[i][j]) p=1;
//                //判断请求是否超过该进程所需要的资源数
//                if(p)
//                {
//                    printf("请求资源超过该进程资源需求量，请求失败！
");
//                    fout<<"Failed"<<endl;
//                }
//                else
//                {
//                    for(j=0;j<no2;j++)
//                    if(request[j]>available[j]) q=1;
//                    //判断请求是否超过可用资源数
//                    if(q)
//                    {
//                        printf("没有做够的资源分配，请求失败！
");
//                        fout<<"Failed"<<endl;
//                    }
//                    else   //请求满足条件
//                    {
//                        for(j=0;j<no2;j++)
//                        {
//                            available1[j]=available[j];
//                            allocation1[i][j]=allocation[i][j];
//                            need1[i][j]=need[i][j];
//                    //保存原已分配的资源数，仍需要的资源数和可用的资源数
//
//                            available[j]=available[j]-request[j];
//                            allocation[i][j]+=request[j];
//                            need[i][j]=need[i][j]-request[j];
//                            //系统尝试把资源分配给请求的进程
//                        }
//                        print();
//                        check();     //检测分配后的安全性
//                        if(r==0)   //如果分配后系统不安全
//                        {
//                            for(j=0;j<no2;j++)
//                            {
//                                available[j]=available1[j];
//                                allocation[i][j]=allocation1[i][j];
//                                need[i][j]=need1[i][j];
//                    //还原已分配的资源数，仍需要的资源数和可用的资源数
//                            }
//                            printf("返回分配前资源数
");
//                            print();
//                        }
//                    }
//                }printf("
你还要继续分配吗？Y or N ?
");
//                //判断是否继续进行资源分配
//                    c=getche();
//        }while(c=='y'||c=='Y');
//    }
}

结果如下

因为题目只是判断当前状态的request是否处于安全状态，所以只需把当前状态的结果输出即可，如果继续求每个进程的request是否可以分配，只需把注释打开，稍微调一下代码

参考：https://blog.csdn.net/qq_34164532/article/details/78754657