01.C++

mccjuran

已于 2023-12-07 16:01:57 修改

阅读量49

点赞数

文章标签： c++ 开发语言

于 2023-05-29 16:43:22 首次发布

本文链接：https://blog.csdn.net/weixin_57211598/article/details/130931571

版权

1.元素逆置

//数组中的元素逆序排列
    string st[] = { "123","abc","ABC","233","w","a1","a2","a3","你好世界","Hello World!" ,"上有六龙回日之高标，下有冲波逆折之回川。"};

   //数据占用的总内存  除以  单个元素所占的空间，

   //    sizeof(num)     /   sizeof(num[0])
    for (size_t i = 0; i < sizeof(st) / sizeof(st[0]); i++)
    {
        cout << st[i] << endl;
    }
    cout << "/[[[分割线]]]//\n";
    for (int i = 0; i < sizeof(st) / sizeof(st[0]) / 2; i++)
    {
        string temp = st[i];
        st[i] = st[sizeof(st) / sizeof(st[0]) - i - 1];
        st[sizeof(st) / sizeof(st[0]) - i - 1] = temp;

    }
    for (size_t i = 0; i < sizeof(st) / sizeof(st[0]); i++)
    {
        cout << st[i] << endl;
    }

2.冒泡排序

	/*冒泡排序*/
	int Arr[] = { 9,6,3,8,5,2,0,7,4,1 };
	
	/*方法1*/
	for (size_t i = 0; i < sizeof(Arr) / sizeof(Arr[0]); i++)
	{
		for (size_t j = i + 1; j < sizeof(Arr) / sizeof(Arr[0]); j++)
		{
			if (Arr[i] < Arr[j])//比较运算符决定正序还是逆序
			{
				Arr[i] += Arr[j];
				Arr[j] = Arr[i] - Arr[j];
				Arr[i] = Arr[i] - Arr[j];
			}
			cout << i << ":" << j << " ";
		}
		cout << endl;
	}
	/*第一次：第0个元素和第1,2,3,4,5,6,7,8,9个元素比较，
	* 第二次：第1个元素和第2,3,4,5,6,7,8,9个元素比较，
	* 第三次：第2个元素和第3,4,5,6,7,8,9个元素比较，
	* 第四次：第3个元素和第4,5,6,7,8,9个元素比较，
	* 第五次：第4个元素和第5,6,7,8,9个元素比较，
	* 第六次：第5个元素和第6,7,8,9个元素比较，
	* 第七次：第6个元素和第7,8,9个元素比较，
	* 第八次：第7个元素和第8,9个元素比较，
	* 第九次：第8个元素和第9个元素比较，
	*
	*
	*/
	cout << "----------------------" << endl;
	for (size_t i = 0; i < sizeof(Arr) / sizeof(Arr[0]); i++)
	{
		cout << Arr[i] << endl;
	}
	cout << "----------------------" << endl;
	/*方法2*/
	for (size_t i = 0; i < sizeof(Arr) / sizeof(Arr[0]) - 1; i++)
	{
		for (size_t j = 0; j < sizeof(Arr) / sizeof(Arr[0]) - i - 1; j++)
		{
			if (Arr[j] > Arr[j + 1])//数组中的每一个都和它后面的元素对比,如果大于就进行交换(正序)
			{
				int temp = Arr[j];
				Arr[j] = Arr[j + 1];
				Arr[j + 1] = temp;
			}
			cout << j << ":" << j + 1 << " ";
		}
		cout << endl;
	}
	/*第一次：第0个元素和第1个元素比较
	* 第二次：第1个元素和第2个元素比较
	* 第三次：第2个元素和第3个元素比较
	* 当内循环一周后,可以确定出第一个最值，此时i++
	* 第九次之后：第0个元素和第一个进行比较
	* 但是这次因为内层减去了外层的循环次数,交换到最后一位的数将不再进行判断
	*/
	cout << "----------------------" << endl;
	for (size_t i = 0; i < sizeof(Arr) / sizeof(Arr[0]); i++)
	{
		cout << Arr[i] << endl;
	}
	cout << "----------------------" << endl;
	/*不同处在于，方法二声明了第三方变量，方法一节约内存*/

3.计算之魂1.3_总和最大区间问题

void Function_00(float ar[])
{
	float max = 0.0f;//当前最大数
	float currentValue = 0.0f;//当前程序运行到的值
	int minIndex = 0;//最小索引
	int maxIndex = 0;//最大索引
 
	for (size_t i = 0; i < 13; i++)
	{
		currentValue = ar[i];
		for (size_t j = i; j < 13; j++)
		{
			if (i != j)
			{
				currentValue += ar[j];
				if (max < currentValue)
				{
					max = currentValue;
					minIndex = i;
					maxIndex = j;
				}
			}
 
		}
	}
	cout << "最大区间值:" << max << endl;
	cout << "当前索引左值:" << minIndex << " 左索引数:" << ar[minIndex] << endl;
	cout << "当前索引右值:" << maxIndex << " 右索引数:" << ar[maxIndex] << endl;
}
void sumMaxRange()
{
	float arry[] = { 1.5f,-12.3f,3.2f,-5.5f,23.2f,3.2f,-1.4f,-12.2f,34.2f,5.4f,-7.8f,1.1f,-4.9f };
	//方法零：穷举：每个数向后加，判断最大值，记录最大值索引
	Function_00(arry);
}

4.银行家算法

#include <iostream>
using namespace std;
 
/*死锁避免(银行家算法)
* A，B，C是项目p1,p2,p3,p4是借贷人
* 贷款方总需的钱      *银行已经分配给贷款方的钱    *借款顺序
	*  A B C				*  A B C				*  A B C
	p1 3 2 2				p1 1 0 0				p1 2 2 2
	p2 6 1 3				p2 6 1 2				p2 0 0 1
	p3 3 1 4				p3 2 1 1				p3 1 0 3
	p4 4 2 2				p4 0 0 2				p4 4 2 0
*银行可分配给贷款方的钱 *借出后还剩下的钱			*借款顺序
	   9 3 6				   0 1 1
*/
 
/// <summary>
/// 判断是否满足放贷
/// </summary>
/// <param name="p">存储银行家的指针，以便于比对</param>
/// <param name="p1">贷款方需要的钱</param>
/// <param name="hLen">表索引行</param>
/// <param name="vLen">表索引列</param>
/// <returns></returns>
int Sort(int* p, int* p1, int hLen, int vLen)
{
	bool FullShow = true;
	int* pTemp = p;
	int person = -1;//记录符合条件的贷款人
	int index = 0;
	int indexZero = 0;//记录是否所有值都为零
	for (int i = 0; i < hLen; i++)
	{
		indexZero = 0;
		index = 0;
		cout << "p" << i + 1 << ": |";
		for (int j = 0; j < vLen; j++)
		{
 
			cout << *p << ":" << *p1 << " ";
			if (*p < *p1)//如果银行家的余额是否大于贷款人的金额，
			{
				cout << "大于 |";
			}
			else
			{
 
				if (*p1 == 0)
				{
					index++;
					indexZero++;
					cout << "归零 |";
				}
				else
				{
					index++;
					indexZero = 0;
					cout << "满足 |";//下次循环后三次都满足,记录
				}
 
			}
			p++;
			p1++;
		}
		p = pTemp;
		if (FullShow)
		{
			if (index == vLen && indexZero < vLen)
			{
				person = i;
				FullShow = false;
				//return person;
			}
		}
		cout << "\n-----------------------------------";
		cout << "归零次数统计{" << indexZero << "}++++++++++++++++++++++++++++++++" << endl;
	}
	return person;
}
/// <summary>
/// 放贷
/// </summary>
/// <param name="Available">借出后剩下的钱</param>
/// <param name="Allocation">银行已经分配给贷款方的钱</param>
/// <param name="Need">贷款方还需要的钱</param>
/// <param name="Claim">贷款方需要的总钱</param>
/// <param name="vLen">表格索引列</param>
void Lending(int* Available, int* Allocation, int* Need, int* Claim, int vLen)
{
	int temp;
	for (int i = 0; i < vLen; i++)
	{
		//总需要的贷款-银行家分配给借款方的钱
		temp = *Claim - *Allocation;
		if (temp != 0)
		{
			*Available -= temp;//借出后剩下的钱-1		011
			*Allocation += temp;//已分配给贷款方的钱加一   612
			*Need -= temp;//借款顺序减一 001
		}
		Claim++;
		Allocation++;
		Available++;
		Need++;
	}
}
/// <summary>
/// 还贷
/// </summary>
/// <param name="Allocation">银行分配给贷款方的钱减少</param>
/// <param name="Available">借出后剩下的钱增加</param>
/// <param name="vLen">表格索引列</param>
void RepayALoan(int* Allocation, int* Available, int vLen)
{
	for (int i = 0; i < vLen; i++)
	{
		*Available += *Allocation;
		*Allocation = 0;
		Available++;
		Allocation++;
	}
	//将满足条件的《银行已经分配给贷款方的钱》返还给银行家(银行家Add)
}
void print(int* p, int hLen, int vLen)
{
	cout << "------------------------" << endl;
	for (int i = 0; i < hLen; i++)
	{
		for (int j = 0; j < vLen; j++)
		{
			cout << " | " << *p << " | ";
			p++;
		}
		cout << "\n------------------------" << endl;
	}
	cout << endl;
}
void BankerAlgorithm()
{
#pragma region 银行家所有的钱，贷款方需要借款的钱
	//银行可以分配给贷款方的钱
	int Resource[3] = { 9,3,6 };
	//贷款方需要的总钱
	int Claim[4][3] =
	{
		{3,2,2},//p1
		{6,1,3},//p2
		{3,1,4},//p3
		{4,2,2} //p4
	};
#pragma endregion
 
#pragma region 第一次借款
	//借出后剩下的钱
	int Available[] = { 0,1,1 };
	//银行已经分配给贷款方的钱
	int Allocation[4][3] =
	{
		{1,0,0},//p1
		{6,1,2},//p2
		{2,1,1},//p3
		{0,0,2} //p4
	};
#pragma endregion
 
#pragma region 借款顺序;(银行第二次放贷),同时也是银行家收款顺序
	//借款顺序，p1代表一个借款人
	string order[] = { "p1","p2","p3","p4" };
	//贷款方还需要的钱//最本项目需要进行计算
	int Need[4][3] =
	{
 
		{2,2,2},//p1
		{0,0,1},//p2
		{1,0,3},//p3		
		{4,2,0} //p4
 
	};
#pragma endregion 
	int* p = NULL;
	int* p1 = NULL;
 
	int hLen = 4;//表格水平
	int vLen = 3;//表格垂直
	//银行家应该如何放贷
	//判断贷款人需要的钱和银行家剩下的钱，以便继续放贷；
	p = Available;//银行家借出后剩下的钱
	p1 = &Need[0][0];//贷款方需要的钱
	/*do
	{*/
	for (int i = 0; i < hLen; i++)
	{
 
 
		int person = Sort(p, p1, hLen, vLen);
		if (person == -1)
		{
			cout << "银行家破产" << endl;
			return;
		}
		else
		{
			cout << "/" << order[person] << ":满足条件" << "****/\n" << endl;
			//借出后剩下的钱,银行已经分配给贷款方的钱,贷款方需要的钱,贷款方总需的钱
			Lending(&Available[0], &Allocation[person][0], &Need[person][0], &Claim[person][0], vLen);
			cout << "******贷款方需要的钱********\n";
			print(p1, hLen, vLen);
			cout << "**银行已经分配给贷款方的钱**\n";
			print(&Allocation[0][0], hLen, vLen);
			cout << "****银行家手中还剩下的钱****\n";
			print(&Available[0], 1, vLen);
			cout << "***贷款人项目满足进行还贷***\n";
			RepayALoan(&Allocation[person][0], &Available[0], vLen);
			cout << "\n**银行已经分配给贷款方的钱**\n";
			print(&Allocation[0][0], hLen, vLen);
			cout << "****银行家手中还剩下的钱****\n";
			print(&Available[0], 1, vLen);
 
		}
	}
}
int main()
{
	BankerAlgorithm();
}

mccjuran

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
01.C++

string st[] = { "123","abc","ABC","233","w","a1","a2","a3","你好世界","Hello World!" ,"上有六龙回日之高标，下有冲波逆折之回川。cout
复制链接

扫一扫