银行家算法

最新推荐文章于 2024-06-17 15:39:16 发布
最新推荐文章于 2024-06-17 15:39:16 发布
阅读量4.4k 收藏 22
点赞数 2
分类专栏： 面试复习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xchaha/article/details/80340404
版权

emmmm。。这个是很久以前做的 为了防止文件丢失 直接把实训报告贴在这以作保存

用程序实现银行家算法

 

 

1.   课程设计内容

整个银行家算法程序包括

void showstart(int m, int n);// 以数组形式显示出m 个进程对 n 类资源已有资源

void showneed(int m, intn);// 以数组形式显示出 m 个进程对 n 类资源仍需求资源

void showinventory(intn);//以数组形式显示出  资源的库存

void showall(int m, intn);//所有数据显示

bool IsNotSafe(int m,int n);//系统安全性检查，判断不安全

void ChangData(int n,int k);//申请资源数不超库存和需求，改变数据

void NotSafeBack(int n,int k);//判断不安全，将数据还回去

 

以及主程序intmain（）

2.   背景知识

银行家算法是一个用来避免系统进入死锁状态的算法，用它可以判断系统的安全性，如果系统当前处于安全状态，则可以为申请资源的进程分配资源，如果不是安全状态，则不能为申请资源的进程分配资源。 

银行家算法执行过程中，首先判断申请资源的进程所申请的资源数目是否合法，若是合法的，则可以为其进行试分配，再利用安全性算法求出安全序列，·如果存在安全序列，则说明可以给申请资源的进程分配资源，分配成功，继续为其它进程服务。如果找不到安全序列，则说明为该进程分配资源后系统会进入不安全状态，所以不能为该进程分配资源，使该进程进入阻塞状态。若申请资源的进程申请的资源数目不合法，则不需要进行试分配，直接使其进入阻塞状态，处理其他申请资源的进程。 

3.   设计步骤与方法

3.1.  步骤1：需求分析

3.1.1.   步骤1.1：问题描述

当系统在进行资源管理时，如果对进程申请的资源分配不当，可能会使系统进入死锁状态，因而后面到来的进程也无法顺利执行。银行家算法中，要对当前申请资源的进程申请资源的数目进行判断，如果可以试分配，则试求出一个安全序列，如果可以求出，则说明给这个进程分配资源后系统不会进入不安全状态，将该进程申请的资源分配给他，若求不出安全序列，则说明将资源分配给该进程后系统会进入不安全状态，所以就使该进程进入阻塞状态，等待以后可以分配资源时再执行该进程，然后系统继续服务其它进程。通过这样一个过程，可以有效避免系统进入死锁状态。

3.1.2步骤1.2：基本要求

（1）对各个进程的进程名，最大需求资源，已分配资源，系统可用资源等进行有序的输入。

 （2）对申请资源的进程要有合法性判断（如进程名，申请资源数等）。

（3）  若有进程申请资源，首先要对它申请的资源数进行判断。

（4）  在上面判断合法的前提下进行试分配，利用银行家算法求出安全序列,如果可以求出安全序列，则为该进程分配资源，询问是否继续输入，否则使它报错，退回已请求资源，询问是否继续输入。

3.1.3步骤1.3：概要分析

在避免死锁的算法中，允许进程动态地申请资源，系统在进行资源分配之前，先计算资源分配的安全性。若此次分配不会使系统进入不安全状态，便将资源分配给该进程否则进程等待。

所谓安全状态是指系统能按某种顺序如<p1，p2，……，pn>（称<p1，p2，……，pn>为安全序列），就这样来为每个进程分配资源，直至最大需求。使每个进程都可以顺序地执行完毕。若系统不存在这样一个安全序列，那么系统此时会进入不安全状态。

虽然并非所有的不安全状态都会产生死锁状态，但当系统进入不安全状态后，便可能进而进入死锁状态；反之，只要系统处于安全状态，系统便可避免进入死锁状态。因此，避免死锁的实质在于，如何使系统不进入不安全状态，银行家算法就是用来判断某种情况会不会进入不安全状态。

3.2.  步骤2：设计

3.2.1步骤2.1：概要设计


3.2.2步骤2.2：详细设计

三个主要函数：1改变数据 2.判断不安全，将数据还回去3.判断安全性并找出安全序列

void ChangData(int n, int k);//申请资源数不超库存和需求，改变数据

{

       for(int j = 0; j < n; j++)

       {

              Inventory[j]= Inventory[j] - Request[j];//库存-请求

              Start[k][j]= Start[k][j] + Request[j];//现有+请求

              Need[k][j]= Need[k][j] - Request[j];//需求-请求

}

}

void NotSafeBack(int n, int k);//判断不安全，将数据还回去

{

       cout<<"正在退回资源"<<endl;

       for (int j = 0;j < n; j++)

       {

              Inventory[j]= Inventory[j] + Request[j];

              Start[k][j]= Start[k][j] - Request[j];

              Need[k][j]= Need[k][j] + Request[j];

 

       }

       cout<<"已退回资源"<<endl;

}

bool IsNotSafe(int m, int n);//系统安全性检查，判断不安全

{ 

int work[100];//n/表示剩下可供分配的有效资源数

       intfinish[100];//m表示第i个进程是否可以运行完

       inttemp[100];//mtemp[]用来记录进程安全执行的顺序

       int temp1 ;//标记为需要资源[j]小于剩余可分配有效资源[j]

       int i, j, k =0;

       int Reset=0 ;//判断是否要重循环

       for (i = 0; i< m; i++)//finish[]初始化为否

       {

              finish[i]= 0;

       }

       for (j = 0;j<n; j++)//初始化剩余可分配有效资源数为库存值

       {

              work[j]= Inventory[j];

       }

       for (i = 0;i<m; i++)//遍历进程看是否有刚好满足的

       {

              if(Reset==1)

              {

                     i= 0;//重头来过以免漏掉

              }

              Reset=0;

              temp1 =1;//标记为需要资源[j]小于剩余可分配有效资源[j]

              if (finish[i]== 1)continue;//已经分配过的跳掉

              for (j =0; j<n; j++)

              {//遍历资源i进程还需要的资源[j]是否大于剩余可分配有效资源[j]

                     if(Need[i][j]>work[j])

                     {

                            temp1= 0;

                            break;

                     }

              }

              if(finish[i] == 0 && temp1 == 1)//未分配过并且需要资源[j]小于剩余可分配有效资源[j]

              {//i进程还需要的资源[j]小于剩余可分配有效资源[j]

              //那么这个进程就可以执行完然后将资源归还系统

       //即可分配有效资源[j]=该进程全部现有资源[j]+原可分配有效资源[j]

                     for(j = 0; j<n; j++) //for1

                     {

                            work[j]= work[j] + Start[i][j];

                     }

                     finish[i]= 1;

                     temp[k]= i+1;//保存序列

                     k++;

                     Reset=1;

              }

             

       }

       for (i = 0;i<m; i++) //遍历下看看是否有安全序列

       {

              if(finish[i]==0)

              {

                     cout<< endl;

                     cout<< " 系统不安全!!! 本次资源申请不成功!!!"<< endl;

                     cout<< endl;

                     return1;

              }

       }

       //正确返回否值

       cout <<endl;

       cout <<" 经安全性检查，系统安全，本次分配成功。" << endl;

       cout <<endl;

       cout <<" 本次安全序列：";

       for (i = 0;i<m; i++)

       {

              cout<< "进程" << temp[i] ;

              if(i<m-1)cout<<"->";

              }

       cout <<endl << endl;;

       return 0;

}

4.   设计结果及分析

  


输入数据后经过安全性判断恰好能找到安全序列

5.   问题及心得体会

本来以为这个程序应该很简单很快就能好，结果实际操作起来却花了将近2周，虽然断断续续。使用的是好久没碰的c++，感觉特别是数组有点忘，就先看了几天《易学c++》温习一下。

       最开始我尝试了个简单版本的，就是以2维数组将一切包括进程数，资源类数，初始进程拥有资源，进程最大需求值先提前给出。然后用户只能输入请求的值。相对简易，大致为后来修改立下奠基。

   第一次修改将原来默认给定的数值全部改为动态输入的数据，以数组来存储，这就有了第二代版本，唯一缺点是我把初始进程拥有资源定义为0，这就大大增加了测试的麻烦程度，每次都得1个个数据申请判断，很烦因此推动我继续改进版本。

       第三代版本出现了，这一次，我将它更改为可输入进程数，资源类数，初始进程拥有资源，还可多次输出，并添加上最为核心的安全性判断法。然而，这一改变过程，却导致很多错误，导致一直卡在瓶颈，导致我一再几天没有进度。通过思考还有将每次变化数据显示出来，我很快发现了问题所在。

由于第二次版本的修改，我将初始进程拥有资源定义为0，因此当时的第m个进程还需要第n类资源的资源量（Need值）可以看作是等于第m个进程对第n类资源最大资源需求量（MAX值），所以当时也没注意，才发现这个导致我测试频频饮恨的罪魁祸首；接着由于数组存在i[0],这与我们通俗叫法中的第一第二…这种从一开始的相差了一位，导致常常出错，经过数据测试，我也及时通过+1和-1来解决这个问题；然后判断安全性那里是我花了我最长时间的，总是搞不清楚哪里出错，其中一个就是缺乏对分配完成与未完成区别对待，导致多次将分配完的数据重复输入，后来设了一个finish[i]来标识是否完成分配同时循环开头用if语句判断是否跳过，缩短了时间；最后还是在安全性这里，经过多次数据测试发现，一些例题能成功找出正确的安全序列，有些却报错，再对那些报错和正确的数据断点观察后发现，原来由于i++的原因导致开始时第一个数被跳掉，因此添加判断标志Reset=0，来判断是否要重循环，是的话i=0，以免漏掉。以上都是我所遇到的典型错误，细小那些就不多提。

      经过这次课程设计，让我重新体会到编程的乐趣，那种专研后找到解决错误的快感，同时加深了我对银行家算法以及c++的了解，这次课程设计使我受益匪浅。

 

 源码

#include<iostream>
#include<iomanip>
#include<string>
using namespace std;
//int Start[5][4] = { { 0, 0, 3, 2 }, { 1, 0, 0, 0 }, { 1, 3, 5, 4 }, { 0, 3, 3, 2 }, { 0, 0, 1, 4 } };
int Start[100][100];//m个进程对n类资源初始拥有量 
int MAX[100][100];//m个进程对n类资源最大资源需求量 
int Need[100][100];//m个进程还需要n类资源的资源量 
int Inventory[100];//库存量
int Request[100];// 需要资源
void showstart(int m, int n);// 以数组形式显示出 m 个进程对 n 类资源已有资源
void showneed(int m, int n);// 以数组形式显示出 m 个进程对 n 类资源仍需求资源
void showinventory(int n);//以数组形式显示出  资源的库存
void showall(int m, int n);//所有数据显示

void ChangData(int n, int k);//申请资源数不超库存和需求，改变数据
void NotSafeBack(int n, int k);//判断不安全，将数据还回去
bool IsNotSafe(int m, int n);//系统安全性检查，判断不安全

int main()
{

	//初始化 m个进程对n类资源最大资源需求量 
	int m, n;//输入总进程数m和总资源类数n
	cout << "总进程数为：";
	cin >> m;
	cout << "总资源数类数：";
	cin >> n;
	//库存量输入
	for (int j = 0; j < n; j++)
	{
		cout << "第" << j + 1 << " 类总资源数为：";
		cin >> Inventory[j];
	}
	showinventory(n);

	//测试数据int MAX[4][3]={ { 8, 6, 7 }, { 6, 7, 8 }, { 4, 5, 2 }, { 4, 6, 3 } };

	for (int i = 0; i < m; i++)
	{

		for (int j = 0; j <n; j++)
		{
			cout << "第" << i + 1 << "个进程对第" << j + 1 << "类资源的最大需求量为：";
			cin >> MAX[i][j];
		}

		cout << endl;
	}

	//显示给客户看已输入的m个进程对n类资源最大资源需求量  以便下一步输入
	cout << "现在以数组形式显示出 " << m << " 个进程对 " << n << " 类资源最大资源需求量" << endl;
	for (int i = 0; i < m; i++)
	{
		cout << "{";
		for (int j = 0; j < n; j++)
		{
			cout << setw(2) << MAX[i][j];
			if (j<n - 1)cout << ",";
		}
		cout << "}" << endl;
	}

	//m个进程已经得到n类资源的资源量初始化
	cout << "请初始化各线程现有的资源" << endl;
	for (int i = 0; i < m; i++)
	{

		for (int j = 0; j <n; j++)
		{

			cout << "第" << i + 1 << "个进程已拥有的第" << j + 1 << "类资源数为：";
			cin >> Start[i][j];
			Need[i][j] = MAX[i][j] - Start[i][j];//需求量应当为最大值-初始拥有的
		}
		cout << endl;
	}

	showneed(m, n);
	cout << endl;
	showstart(m, n);

	//正式运行
	//int need[100][100];//m个进程还需要n类资源的资源量 
	//int request;// 需要资源
	char flag = 'y';
	while (flag == 'y' || flag == 'Y')//while1
	{
		//初始化请求资源
		for (int i = 0; i < n; i++)
		{
			Request[i] = 0;
		}
		int rj = -100;
		int  rl = -100;
		//第一步输入申请的进程号并判断是否合法
		while (rj <= 0 || rj >m) //while2
		{
			cout << " 请输入需要申请资源的进程号（从1到" << m << "!）:";
			cin >> rj;
			if (rj <= 0 || rj >m)
			{
				cout << " 输入的进程号不存在，请重新输入!" << endl;
				continue;
			}

		} //end while2
		//
		//第二步输入要申请的资源
		for (int j = 0; j <n; j++)
		{

			rl = j;
			cout << "您希望为第 " << rj << " 进程申请多少 " << rl + 1 << "类资源:";
			cin >> Request[rl];
			//对申请资源数是否超库存和需求的判断
			if (Request[rl]>Inventory[rl])
			{
				cout << endl;
				cout << "您的请求无法完成，该" << rl << "类资源并没有那么多库存" << endl;
				cout << endl;
			}
			else if (Request[rl]>Need[rj - 1][rl])
			{
				cout << endl;
				cout << " 进程" << rj << "申请的资源数大于它还需要的" << rl << "类资源的资源量!";
				cout << "申请不合理，出错!请重新选择!" << endl << endl;
				cout << endl;
			}
		}
		ChangData(n, rj - 1);
	 	 
		if (IsNotSafe(m, n) == 1)
		{
			showall(m, n);
			//判断不安全，将数据还回去
			NotSafeBack(n, rj - 1);
			 

		}

		showall(m, n);
		//判断是否要继续
		cout << "请输入是否要继续申请资源（y / n）？" << endl;
		cin >> flag;
	}//end while1

}
//显示类函数
void showstart(int m, int n)
{

	cout << "现在以数组形式显示出 " << m << " 个进程对 " << n << " 类资源已有资源" << endl;
	for (int i = 0; i < m; i++)
	{
		cout << "{";
		for (int j = 0; j < n; j++)
		{
			cout << setw(2) << Start[i][j];
			if (j < n - 1)cout << ",";
		}
		cout << "}" << endl;
	}
}

//m个进程还需要n类资源的资源量 
void showneed(int m, int n)
{


	cout << "现在以数组形式显示出 " << m << " 个进程对 " << n << " 类资源仍所需资源" << endl;
	for (int i = 0; i < m; i++)
	{
		cout << "{";
		for (int j = 0; j < n; j++)
		{
			cout << setw(2) << Need[i][j];
			if (j < n - 1)cout << ",";
		}
		cout << "}" << endl;
	}
}
void showinventory(int n)
{
	/*
	for (int j = 0; j < n; j++)
	{

	cout << "第" << j +1<< " 类总资源数为：";
	cout << Inventory[j];
	cout << endl;

	}*/
	cout << "现在以数组形式显示出 " << n << " 类总资源数为：" << endl;
	cout << "{";
	for (int j = 0; j < n; j++)
	{
		cout << setw(2) << Inventory[j];
		if (j < n - 1)cout << ",";
	}
	cout << "}" << endl;


}
void showall(int m, int n)
{
	showstart(m, n);

	showneed(m, n);
	showinventory(n);
}
void ChangData(int n, int k)
{
	for (int j = 0; j < n; j++)
	{
		Inventory[j] = Inventory[j] - Request[j];//库存-请求
		Start[k][j] = Start[k][j] + Request[j];//现有+请求
		Need[k][j] = Need[k][j] - Request[j];//需求-请求

	}
}
void NotSafeBack(int n, int k)
{
	cout << "正在退回资源" << endl;
	for (int j = 0; j < n; j++)
	{
		Inventory[j] = Inventory[j] + Request[j];
		Start[k][j] = Start[k][j] - Request[j];
		Need[k][j] = Need[k][j] + Request[j];

	}
	cout << "已退回资源" << endl;
}

bool IsNotSafe(int m, int n)
{

	int work[100];//n/表示剩下可供分配的有效资源数
	int finish[100];//m表示第i个进程是否可以运行完
	int temp[100];//mtemp[]用来记录进程安全执行的顺序
	int temp1;//标记为需要资源[j]小于剩余可分配有效资源[j]
	int i, j, k = 0;
	int Reset = 0;//判断是否要重循环
	//finish[]初始化为否
	for (i = 0; i < m; i++)
	{
		finish[i] = 0;
	}
	//初始化剩余可分配有效资源数为库存值
	for (j = 0; j<n; j++)
	{
		work[j] = Inventory[j];
	}
	for (i = 0; i<m; i++)//遍历进程 看是否有刚好满足的
	{
		if (Reset == 1)
		{
			i = 0;//重头来过 以免漏掉
		}
		Reset = 0;
		temp1 = 1;//标记为需要资源[j]小于剩余可分配有效资源[j]
		if (finish[i] == 1)continue;//已经分配过的跳掉
		for (j = 0; j<n; j++)
		{

			//遍历资源 i进程还需要的资源[j]是否大于剩余可分配有效资源[j]
			if (Need[i][j]>work[j])
			{
				temp1 = 0;
				break;
			}

		}
		if (finish[i] == 0 && temp1 == 1)//未分配过并且需要资源[j]小于剩余可分配有效资源[j]
		{
			//i进程还需要的资源[j]小于剩余可分配有效资源[j]
			//那么这个进程就可以执行完 然后将资源归还系统
			//即可分配有效资源[j]=该进程全部现有资源[j]+原可分配有效资源[j]
			for (j = 0; j<n; j++) //for1
			{
				work[j] = work[j] + Start[i][j];
			}
			finish[i] = 1;
			temp[k] = i + 1;//保存序列
			k++;
			Reset = 1;
		}

	}

	for (i = 0; i<m; i++) //遍历下看看是否有安全序列
	{ 
		if (finish[i] == 0)
		{
			cout << endl;
			cout << " 系统不安全!!! 本次资源申请不成功!!!" << endl;
			cout << endl;
			return 1;
		}
	}
	//正确返回否值
	cout << endl;
	cout << " 经安全性检查，系统安全，本次分配成功。" << endl;
	cout << endl;
	cout << " 本次安全序列：";
	for (i = 0; i<m; i++)
	{
		cout << "进程" << temp[i];
		if (i<m - 1)cout << "->";
	}
	cout << endl << endl;;
	return 0;
}



xchaha
关注
  • 2
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
使用java实现银行家算法
08-25
"使用Java实现银行家算法" 银行家算法是操作系统中的一种资源分配算法，用于避免死锁和饥饿现象。该算法的主要思想是，系统中有多个资源和进程，进程需要请求资源来执行任务，系统需要确保资源的分配是安全的，即...
银行家算法详解
nbykcu的博客
06-04 753
银行家算法（Banker's Algorithm）是一种经典的死锁避免算法，由计算机科学家Edsger Dijkstra在1965年提出。它主要用于操作系统中的资源分配，确保系统能够安全地进行资源分配和释放，避免因资源分配不当而导致的死锁。银行家算法的基本思想类似于银行在贷款时要保证其有足够的资金以应对所有客户的最大需求，以免因资金周转不灵而导致破产。
计算机考研408-操作系统-银行家算法
记录学习
06-17 1204
摘要：介绍了计算机考研操作系统中避免死锁的银行家算法的原理、解题即C语言代码实现
银行家算法c++
k5426244的博客
01-04 1933
假设在进程并发执行时进程i提出请求j类资源k个后， 表示为Requesti[j]=k,系统按下述步骤进行安全检查：1.如果Requesti≤Needi则继续以下检查， 否则显示需求申请超出最大需求值的错误。2. 如果Requesti≤Available则继续以下检查， 否则显示系统无足够资源， Pi阻塞等待。
一句话+一张图说清楚——银行家算法
热门推荐
土豆洋芋山药蛋的博客
05-08 15万+
本文试图用一句话+一张图说清楚操作系统中的银行家算法。我相信用一句话可以讲清楚一个算法的核心思想，一张图可以描述整个算法的操作步骤。但本人能力有限，错误之处望大家指出，多谢。 一句话： 当一个进程申请使用资源的时候，银行家算法通过先 试探 分配给该进程资源，然后通过安全性算法判断分配后的系统是否处于安全状态，若不安全则试探分配作废，让该进程继续等待。 那么此时会有一个问题，...
数理方法习题 前六章.pdf
08-03
数理方法习题 前六章
某大型制造企业IT蓝图规划及实施路线.pptx
08-03
某大型制造企业IT蓝图规划及实施路线.pptx
基于Springboot和Vue的社区团购系统设计源码 社区团购系统设计代码（98分期末优秀大作业）
08-03
社区团购系统设计源码（高分毕设），个人经导师指导并认可通过的98分毕业设计项目，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者。也可作为课程设计、期末大作业。包含全部项目源码[代码]、该项目可以直接作为毕设使用。项目技术栈：前端是vue，后端是springboot，项目代码都经过严格调试，代码没有任何bug！ 系统源码（高分毕设），个人经导师指导并认可通过的98分毕业设计项目，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者。也可作为课程设计、期末大作业。包含全部项目源码[代码]、该项目可以直接作为毕设使用。项目技术栈：前端是vue，后端是springboot，项目代码都经过严格调试，代码没有任何bug！ 系统源码（高分毕设），个人经导师指导并认可通过的98分毕业设计项目，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者。也可作为课程设计、期末大作业。包含全部项目源码[代码]、该项目可以直接作为毕设使用。项目技术栈：前端是vue，后端是springboot，项目代码都经过严格调试，代码没有任何bug！
去哪儿旅游&小红书-旅行行业：2023五一旅行趋势报告—想出去玩.pdf
最新发布
08-03
去哪儿旅游&小红书-旅行行业：2023五一旅行趋势报告—想出去玩
基于matlab设计的火焰检测定位.zip
08-03
在MATLAB中，可以使用多种方法进行车牌、人脸、车道线、表盘检测、行人识别和行为识别。以下是一些常见的方法： 1. 车牌检测：可以使用基于图像处理和机器学习的方法来检测车牌。常见的方法包括颜色过滤、形态学操作、边缘检测和字符分割等。 2. 人脸检测：可以使用基于特征提取和分类的方法来检测人脸。常见的方法包括Haar级联分类器、人工神经网络和深度学习方法等。 3. 车道线检测：可以使用基于边缘检测和曲线拟合的方法来检测车道线。常见的方法包括Canny边缘检测和霍夫变换等。 4. 表盘检测：可以使用基于特征提取和机器学习的方法来检测表盘。常见的方法包括颜色过滤、形态学操作、边缘检测和特征匹配等。 5. 行人识别：可以使用基于特征提取和分类的方法来识别行人。常见的方法包括HOG特征提取、SIFT特征提取和深度学习方法等。 6. 行为识别：可以使用基于特征提取和分类的方法来识别行为。常见的方法包括间接算法、基于模型的方法和深度学习方法等。 以上只是一些常见的方法，具体的实现还需要根据具体的问题和数据来选择合适的方法。MATLAB提供了丰富的图像处理和机器学习工具，可以方便地实现这些功能。
华工数字信号处理-DTMF信号的产生与识别 (1).doc
08-03
华工数字信号处理-DTMF信号的产生与识别 (1).doc
基于Springboot和Vue的社区团购系统设计源码 社区团购系统设计代码（优秀毕业设计）
08-03
社区团购系统设计源码（高分毕设），个人经导师指导并认可通过的98分毕业设计项目，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者。也可作为课程设计、期末大作业。包含全部项目源码[代码]、该项目可以直接作为毕设使用。项目技术栈：前端是vue，后端是springboot，项目代码都经过严格调试，代码没有任何bug！ 系统源码（高分毕设），个人经导师指导并认可通过的98分毕业设计项目，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者。也可作为课程设计、期末大作业。包含全部项目源码[代码]、该项目可以直接作为毕设使用。项目技术栈：前端是vue，后端是springboot，项目代码都经过严格调试，代码没有任何bug！ 系统源码（高分毕设），个人经导师指导并认可通过的98分毕业设计项目，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者。也可作为课程设计、期末大作业。包含全部项目源码[代码]、该项目可以直接作为毕设使用。项目技术栈：前端是vue，后端是springboot，项目代码都经过严格调试，代码没有任何bug！
【参数辨识】基于matlab粒子群算法求解异步电动机的参数估计优化问题【含Matlab源码 6764期】.mp4
08-03
Matlab研究室上传的视频均有对应的完整代码，皆可运行，亲测可用，适合小白； 1、代码压缩包内容 主函数：main.m； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2019b；若运行有误，根据提示修改；若不会，私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开main.m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可私信博主或扫描视频QQ名片； 4.1 博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作
数学物理方法-期末-兰州城市学院.pdf
08-03
数学物理方法-期末-兰州城市学院
MDM+ESB解决方案.pptx
08-03
MDM+ESB解决方案.pptx
基于matlab的ConvMixer算法识别7个类别的对象.zip
08-03
基于matlab的ConvMixer算法识别7个类别的对象.zip
银行家算法实现与详解
【资源摘要信息】: "银行家算法是一种避免操作系统死锁的策略，主要应用于多道程序设计环境中，确保系统能够安全地分配资源。本资源包含了银行家算法的详细实现，包括数据结构、算法流程以及课程设计的相关内容。" ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值