银行家算法C++

于 2023-02-15 10:42:29 发布
阅读量261 收藏 1
点赞数
文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Liang_1_/article/details/129039086
版权

"该代码开源免费,如有疑问欢迎咨询CSDN@一支王同学"
#include <iostream>
#include <string>
#include <stdlib.h>
using namespace std;
void Find_Security_Sequence(int, int, int*, int*, bool*, int**, int**);
void Dfs(int, int, int, int*, int*, int*, bool*, int**, int**);
void Print_Brief();
int flag = 0;
int all_Ans[101][101] = { 0 };        // 存储所有答案
int all_i = 0;                        // 答案下标, 总共有几种安全序列, all_i 就有多大
int main()
{
    Print_Brief();
    /*********************** 输入模块(开始) *********************************/
    int n, m;        // n 个进程, m 类资源
    cout << "请分别输入进程数目和资料种类数 n 和 m 为：";
    cin >> n >> m;

    int* Resource = new int[m];
    string* Res_name = new string[m];
    cout << "请输入这" << m << "种资源分别的名称：";
    for (int i = 0; i < m; i++)
        cin >> Res_name[i];

    cout << "请输入这" << m << "种资源分别的个数：";
    for (int i = 0; i < m; i++)
        cin >> Resource[i];

    int** Max = new int* [n];
    int** Allocation = new int* [n];
    int** Need = new int* [n];
    int* Available = new int[n];
    for (int i = 0; i < n; i++)
    {
        Max[i] = new int[m];
        Allocation[i] = new int[m];
        Need[i] = new int[m];
    }

    cout << "请输入最大需求矩阵 Max(行数：" << n << "，列数：" << m << ")：" << endl;
    for (int i = 0; i < n; i++)
        for (int j = 0; j < m; j++)
            cin >> Max[i][j];

    cout << "请输入分配矩阵 Allocation(行数：" << n << "，列数：" << m << ")：" << endl;
    for (int i = 0; i < n; i++)
        for (int j = 0; j < m; j++)
            cin >> Allocation[i][j];

    for (int i = 0; i < n; i++)            // Need 矩阵初始化
        for (int j = 0; j < m; j++)
            Need[i][j] = Max[i][j] - Allocation[i][j];

    for (int j = 0; j < m; j++)            // Available 矩阵初始化
    {
        int tol = 0;
        for (int i = 0; i < n; i++)
        {
            tol += Allocation[i][j];
        }
        Available[j] = Resource[j] - tol;
    }

    int p_num;
    cout << "请输入提出请求的进程号(从 0 开始编号)：";
    cin >> p_num;
    p_num = 1;        // 就是这里.
    int* Request = new int[m];
    cout << "请输入该进程对这" << m << "种资源分别申请的资源数：";
    for (int i = 0; i < m; i++)
        cin >> Request[i];
    /*********************** 输入模块(结束) *********************************/

    /*********************** 输出模块一(开始) *******************************/
    /*
     * 功能：整洁地输出刚刚已经初始化的内容
    */
    cout << "初始化后的资源分配图如下：" << endl;
    cout << "\t\tMAX\t\tAllocation\tNeed\t\tAvailable" << endl;
    cout << "\t";
    for (int i = 0; i < 4; i++)
    {
        cout << "\t";
        for (int j = 0; j < m; j++)
        {
            cout.setf(ios::left);
            cout.fill(' ');
            cout.width(3);
            cout << Res_name[j];
        }
    }
    cout << endl;
    for (int i = 0; i < n; i++)
    {
        cout << "|   进程P" << i << "   |\t";
        for (int j = 0; j < m; j++)
        {
            cout.setf(ios::left);
            cout.fill(' ');
            cout.width(3);
            cout << Max[i][j];
        }
        cout << "    |\t";
        for (int j = 0; j < m; j++)
        {
            cout.setf(ios::left);
            cout.fill(' ');
            cout.width(3);
            cout << Allocation[i][j];
        }
        cout << "    |\t";
        for (int j = 0; j < m; j++)
        {
            cout.setf(ios::left);
            cout.fill(' ');
            cout.width(3);
            cout << Need[i][j];
        }
        cout << "    |\t";
        for (int j = 0; j < m; j++)
        {
            cout.setf(ios::left);
            cout.fill(' ');
            cout.width(3);
            if (i == 0)
                cout << Available[j];
        }
        if (i != 0)
            cout << "\t |";
        else if (i == 0)
            cout << "|";
        cout << endl;
    }
    cout << endl;
    /*********************** 输出模块一(结束) *******************************/

    /************** 银行家算法第二部分：银行家算法模块(开始) ******************/
    /*
    * [1] Request > Need 则认为出错，因为它所需要的资源数已经超过它所申请的最大值
    */
    for (int i = 0; i < m; i++)
    {
        if (Request[i] > Need[p_num][i])
        {
            cout << "出错[1]：它所需要的资源数已经超过它所申请的最大值。" << endl;
            exit(1);
        }
    }

    /*
    * [2] Request > Available 则认为出错，因为它所需要的资源数已经超过它所申请的最大值
    */
    for (int i = 0; i < m; i++)
    {
        if (Request[i] > Available[i])
        {
            cout << "出错[2]：尚无足够的资源，进程 P" << p_num << " 需等待。" << endl;
            exit(1);
        }
    }

    /*
    * [3] 系统试探性分配请求的资源给进程
    */
    for (int i = 0; i < m; i++)
    {
        Available[i] = Available[i] - Request[i];
        Allocation[p_num][i] = Allocation[p_num][i] + Request[i];
        Need[p_num][i] = Need[p_num][i] - Request[i];
    }
    /************** 银行家算法第二部分：银行家算法模块(结束) ******************/


    /*********************** 输出模块二(开始) *******************************/
    /*
    * 功能： 如果能通过上面 “银行家算法模块”，则整洁地输出一下新的 “资源分配图”(还不是最终的资源分配图)
    */
    cout << "加了新的申请后, 新的资源分配图如下：" << endl;
    cout << "\t\tMAX\t\tAllocation\tNeed\t\tAvailable" << endl;
    cout << "\t";
    for (int i = 0; i < 4; i++)
    {
        cout << "\t";
        for (int j = 0; j < m; j++)
        {
            cout.setf(ios::left);
            cout.fill(' ');
            cout.width(3);
            cout << Res_name[j];
        }
    }
    cout << endl;
    for (int i = 0; i < n; i++)
    {
        cout << "|   进程P" << i << "   |\t";
        for (int j = 0; j < m; j++)
        {
            cout.setf(ios::left);
            cout.fill(' ');
            cout.width(3);
            cout << Max[i][j];
        }
        cout << "    |\t";
        for (int j = 0; j < m; j++)
        {
            cout.setf(ios::left);
            cout.fill(' ');
            cout.width(3);
            cout << Allocation[i][j];
        }
        cout << "    |\t";
        for (int j = 0; j < m; j++)
        {
            cout.setf(ios::left);
            cout.fill(' ');
            cout.width(3);
            cout << Need[i][j];
        }
        cout << "    |\t";
        for (int j = 0; j < m; j++)
        {
            cout.setf(ios::left);
            cout.fill(' ');
            cout.width(3);
            if (i == 0)
                cout << Available[j];
        }
        if (i != 0)
            cout << "\t |";
        else if (i == 0)
            cout << "|";
        cout << endl;
    }
    cout << endl;
    /*********************** 输出模块二(结束) *******************************/

    /************** 银行家算法第二部分：安全性算法模块(开始) ******************/
    int* Work = new int[n];
    for (int i = 0; i < m; i++)
        Work[i] = Available[i];

    bool* Finish = new bool[n];

    for (int i = 0; i < n; i++)
        Finish[i] = false;

    int* ans = new int[n];    // 记录序列的编号
    for (int i = 0; i < n; i++)
        ans[i] = -1;

    cout << ">>> 所申请资源未大于其所需资源，亦未大于此时可利用资源，可以预分配并进行安全性检查 <<<" << endl << endl;

    /* 执行 DFS + 回溯, 找出符合条件的序列 */
    Find_Security_Sequence(n, m, ans, Work, Finish, Need, Allocation);        //!!!!!! 全文最核心的函数 !!!!!!!
    
    if (flag == 0)
    {
        cout << "分配后系统将进入不安全状态，故分配失败。" << endl;
        exit(1);
    }
    /************** 银行家算法第二部分：安全性算法模块(结束) ******************/

    /*********************** 输出模块三(开始) *******************************/
    /*
    * 功能：整洁地输出一下最终的 “资源分配图”
    */
    cout << "预分配后系统是安全的，最终实际的资源分配图如下：" << endl;
    cout << "\t\tMAX\t\tAllocation\tNeed\t\tAvailable\tFinish" << endl;
    cout << "\t";
    for (int i = 0; i < 4; i++)
    {
        cout << "\t";
        for (int j = 0; j < m; j++)
        {
            cout.setf(ios::left);
            cout.fill(' ');
            cout.width(3);
            cout << Res_name[j];
        }
    }
    cout << endl;
    for (int ind = 0; ind < n; ind++)
    {
        int i = ans[ind];
        cout << "|   进程P" << i << "   |\t";
        for (int j = 0; j < m; j++)
        {
            cout.setf(ios::left);
            cout.fill(' ');
            cout.width(3);
            cout << Max[i][j];
        }
        cout << "    |\t";
        for (int j = 0; j < m; j++)
        {
            cout.setf(ios::left);
            cout.fill(' ');
            cout.width(3);
            cout << Allocation[i][j];
        }
        cout << "    |\t";
        for (int j = 0; j < m; j++)
        {
            cout.setf(ios::left);
            cout.fill(' ');
            cout.width(3);
            cout << Need[i][j];
        }
        cout << "    |\t";
        for (int j = 0; j < m; j++)
        {
            cout.setf(ios::left);
            cout.fill(' ');
            cout.width(3);
            Available[j] += Allocation[i][j];
            cout << Available[j];
        }
        cout << "    |\tture\t|";
        cout << endl;
    }
    cout << endl;
    cout << "上述资源分配图的安全序列为:";
    for (int i = 0; i < n; i++)
    {
        if (i != n - 1)
            cout << "P" << ans[i] << "-->";
        else
            cout << "P" << ans[i];
    }
    cout << endl << endl;
    cout << "所有的安全序列为：" << endl;
    for (int i = 0; i < all_i; i++)
    {
        for (int j = 0; j < n; j++)
        {
            if (j != n - 1)
                cout << "P" << all_Ans[i][j] << "-->";
            else
                cout << "P" << all_Ans[i][j];
        }
        cout << endl;
    }
    /*********************** 输出模块三(结束) *******************************/

    /*********************** 后续处理(开始) *******************************/
    delete[] ans;
    delete[] Finish;
    delete[] Work;
    for (int i = 0; i < n; i++)
    {
        delete[] Max;
        delete[] Allocation;
        delete[] Need;
    }
    delete[n] Max;
    delete[n] Allocation;
    delete[n] Need;
    delete[] Available;
    delete[] Resource;
    delete[] Res_name;
    /*********************** 后续处理(结束) *******************************/
    return 0;
}
void Print_Brief()
{
    cout << "+---------------------------------------------------------------------------------------+" << endl;
    cout << "|\t\t>>> 欢迎使用银行家算法 <<< \t\t\t\t\t\t|" << endl;
    cout << "|\t    这是一个银行家给多个顾客分发贷款的算法，可以类比到操作系统给进程分配资源。\t|" << endl;
    cout << "|\t这时只要把 银行家 换成 操作系统 ，把 顾客 换成 进程 ，把 资金 换成 资源 ，\t|" << endl;
    cout << "|\t把银行家决定是否放贷时所用的判断过程（即判断顾客是否有信誉和偿还能力）换成\t|" << endl;
    cout << "|\t操作系统决定是否分配资源时所用的判断过程（即判断进程是否能及时归还资源）即可。\t|" << endl;
    cout << "+---------------------------------------------------------------------------------------+" << endl;
}


void Find_Security_Sequence(int n, int m, int* ans, int* Work, bool* Finish, int** Need, int** Allocation)
{
    int* tmp = new int[n];        // 临时记录答案序列的编号
    for (int i = 0; i < n; i++)
    {
        tmp[i] = -1;
    }
    Dfs(n, m, 0, tmp, ans, Work, Finish, Need, Allocation);
    delete[] tmp;
}


void Dfs(int n, int m, int cnt, int* tmp, int* ans, int* Work, bool* Finish, int** Need, int** Allocation)
{
    for (int i = 0; i < n; i++)
    {
        int step = 3;    // 为什么这里要设为 3, 可回见本文前面写的算法设计步骤
        if (Finish[i] == 0)
        {
            for (int j = 0; j < m; j++)
            {
                if (Need[i][j] > Work[j])
                    step = 4;
            }
        }
        else            // 已经分配过了, 就不用考虑该进程, 直接重复循环
            continue;

        if (step != 3)    // step == 4 时将执行 continue
            continue;
        else
        {
            // step == 3 才执行下一步
            for (int j = 0; j < m; j++)
                Work[j] = Work[j] + Allocation[i][j];

            Finish[i] = true;    // 设置为 “分配”
            tmp[cnt] = i;        // 记录临时答案临时
            cnt++;                // 已分配的进程数 + 1
            if (cnt == n)        // 如果资源分配完了(即找到一种分配方案),
            {
                if (flag == 0)
                {
                    for (int j = 0; j < n; j++)
                    {
                        ans[j] = tmp[j];
                    }
                }
                for (int j = 0; j < n; j++)
                {
                    all_Ans[all_i][j] = tmp[j];
                }
                all_i++;
                flag = 1;
            }
            else // cnt != n
            {
                /* 如对代码有疑问, 欢迎咨询 CSDN@一支王同学 */
                Dfs(n, m, cnt, tmp, ans, Work, Finish, Need, Allocation);
            }
            cnt--;                // 已分配的进程数 - 1
            tmp[cnt] = -999;    // 这句话可要可不要
            Finish[i] = false;    // 重置为 “不分配”
            for (int j = 0; j < m; j++)
            {
                Work[j] = Work[j] - Allocation[i][j];
            }
        }
    }
}
/***** 该代码开源免费,如有疑问欢迎咨询CSDN@一支王同学 *****/

 

优化大师傅
关注
银行家算法c++
11-26
实验目的 对死锁避免中的银行家算法作进一步理解。 加深理解死锁的概念。 加深理解安全序列和安全状态的概念。 通过编程，掌握银行家算法分配资源的一步步实现过程。
银行家算法 c++
11-08
采用c++编写的银行家算法，对于计算机类专业的同学，这是必须学习的算法，
银行家算法C++程序
dingtangshi5752的博客
04-20 307
此程序在Windows10 CodeBlocks17.12环境下测试运行，其他编程环境未经测试！ 作业需求↓↓↓↓↓↓ 运行效果图如下 （codeblocks下载地址http://www.codeblocks.org/downloads/binaries） C++代码 ...
银行家算法（C++实现）
热门推荐
m0_58136789的博客
11-23 2万+
操作系统实验内容，银行家算法的实现，基于C++语言
银行家算法C++实现（源代码）
09-13
银行家算法（Banker's Algorithm）是一个避免死锁（Deadlock）的著名算法，是由艾兹格·迪杰斯特拉在1965年为T.H.E系统设计的一种避免死锁产生的算法。它以银行借贷系统的分配策略为基础，判断并保证系统的安全运行...
银行家算法 c++实现（代码+报告）
04-05
《银行家算法C++实现详解》 银行家算法是一种经典的资源分配和死锁预防策略，由艾兹格·迪杰斯特拉在1965年提出。它主要用于确保系统在面临资源请求时能够避免死锁的发生，从而保证系统的安全性。在本资料中，我们...
银行家算法 C++
05-23
《银行家算法在C++中的实现》 银行家算法是一种著名的资源分配和死锁预防算法，由艾兹格·迪杰斯特拉在1965年提出，主要用于解决多道程序设计环境中，如何安全地分配有限的系统资源，避免系统进入不安全状态，从而...
银行家算法代码c++
06-20
银行家算法代码 用C语言编写一个简单的银行家算法模拟程序，用银行家算法实现资源分配。程序能模拟多个进程共享多种资源的情形。进程可动态地申请资源，系统按各进程的申请动态地分配资源。要求程序具有显示和打印各进程的某一时刻的资源分配表和安全序列；显示和打印各进程依次要求申请的资源数量以及为某进程分配资源后的有关资源数据的情况。
银行家算法
中文过六级再取名的博客
11-21 319
银行家算法 代码如下： #include<stdio.h> #define resourceNum 3 #define processNum 5 //系统可用（剩余）资源 int available[resourceNum]={3,3,2}; //进程的最大需求 int maxRequest[processNum][resourceNum]={{7,5,3},{3,2,2},{9,...
银行家算法（C++）
qq_45662289的博客
05-31 180
#include <iostream> using namespace std; #define MaxPro 50                       /*最大进程数*/ #define MaxRes 100    &n
C ++ 银行家算法
qq_29233719的博客
01-11 591
我们可以把操作系统看作是银行家，操作系统管理的资源相当于银行家管理的资金，进程向操作系统请求分配资源相当于用户向银行家贷款。 为保证资金的安全,银行家规定: (1) 当一个顾客对资金的最大需求量不超过银行家现有的资金时就可接纳该顾客; (2) 顾客可以分期贷款,但贷款的总数不能超过最大需求量; (3) 当银行家现有的资金不能满足顾客尚需的贷款数额时,对顾客的贷款可推迟支付,但总能使顾客在有
银行家算法c++版
11-08 5064
搞了几天银行家算法，终于搞定了。知识还是得从基础抓起啊。   所谓银行家算法，主要是解决操作系统的进程调度的，解决并发进程的死锁问题。目前，大部分操作系统已经不采用此算法，但此算法去还是很经典的。算法思想非常简单，便于理解。但是，在实现时，发现出现了各种各样的问题。   银行家算法，主要有两部分组成。一是安全检测，其次，就是进程的调度。    银行家算法是死锁避免的经典算法，其核心思想是：进
银行家算法（c++实现）
elexiangchirou的博客
10-28 773
银行家算法（c++实现） ***********图片来源，代码思路参考 银行家算法描述： 在银行中，客户申请贷款的数量是有限的，每个客户在第一次申请贷款时要声明完成该项目所需的最大资金量，在满足所有贷款要求时，客户应及时归还。银行家在客户申请的贷款数量不超过自己拥有的最大值时，都应尽量满足客户的需要。在这样的描述中，银行家就好比操作系统，资金就是资源，客户就相当于要申请资源的进程。 安全序列描述 主要数据结构： process为进程数 resource为资源种类 还会用到一维数组 work[resou
银行家算法c++读写
最新发布
10-24
在C++中实现银行家算法需要定义一些数据结构和函数，如可利用资源向量、最大需求矩阵、分配矩阵、需求矩阵等。同时，还需要实现一些操作函数，如初始化数据、显示系统资源、检查系统是否安全等。在main函数中，需要...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

优化大师傅

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值