C++数组

C++数组

数组是有序的元素序列。若将有限个类型相同的变量的集合命名，那么这个名称为数组名。组成数组的各个变量称为数组的分量，也称为数组的元素，有时也称为下标变量。用于区分数组的各个元素的数字编号称为下标。数组是在程序设计中，为了处理方便， 把具有相同类型的若干元素按有序的形式组织起来的一种形式。 这些有序排列的同类数据元素的集合称为数组。

C++一维数组

一维数组，是由数字组成的以单纯的排序结构排列的结构单一的数组，是计算机程序中最基本的数组。

一、数组有三种定义方法

数据类型 数组名{数组长度}

int main() {
	//数组
	//1、数据类型	数组名{数组长度}
	int arr[5];
	//给数组中的元素进行赋值
	arr[0] = 10;
	arr[1] = 20;
	arr[2] = 30;
	arr[3] = 40;
	arr[4] = 50;

	//访问数据元素
	cout << arr[0] << endl;
	cout << arr[1] << endl;
	cout << arr[2] << endl;
	cout << arr[3] << endl;
	cout << arr[4] << endl;
}

数组名{数组长度} = {值1，值2…}

int main() {
	//数组
	//2、数据类型	数组名{数组长度} = {值1，值2...}
	int arr2[5] = { 60,70,80,90,100 };//如果在初始化数据时候，没有全部填写完，会用0填补剩余数据
	//访问数据元素
	cout << arr2[0] << endl;
	cout << arr2[1] << endl;
	cout << arr2[2] << endl;
	cout << arr2[3] << endl;
	cout << arr2[4] << endl;

	//利用循环 输出数组中的元素
	for (int i = 0; i < 5; i++)
	{
		cout << arr2[i] << endl;
	}
	return 0;
}

数组名[] = {值1，值2…}

int main() {
	//数组
	//3、数据类型	数组名[] = {值1，值2...}
	//定义数组的时候，必须有初始长度
	int arr3[] = { 110,120,130,140,150,160 };
	for (int i = 0; i < 6; i++)
	{
		cout << arr3[i] << endl;
	}
	
	return 0;
}

二、一维数组的用途

1. 可以统计整个数组在内存中的长度
2. 可以获取数组在内存中的首地址

int main() {
	//一维数组名称的用途
	//1、可以统计整个数组在内存中的长度		sizeof(arr)
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	cout << "整个数组占用内存空间为：" << sizeof(arr) << endl;
	cout << "每个元素占用内存空间为：" << sizeof(arr[0]) << endl;
	cout << "数组中元素的个数为：" << sizeof(arr)/ sizeof(arr[0]) << endl;

	//2、可以获取数组在内存中的首地址		cout<<arr<<endl;
	cout << "数组首地址为：" << (int)arr << endl;
	cout << "数组中第一个元素地址为：" << (int)&arr[0] << endl;
	cout << "数组中第二个元素地址为：" << (int)&arr[1] << endl;

	//3、数组名是常量，不可以进行赋值操作
	//arr = 100;错误

	return 0;
}

三、从数组中寻找最大值

先认定一个最大值（通常是数组中第一个元素），访问数组中的每个元素，如果这个元素比我认定的最大值要大，更新最大值

int main() {
	//五只小猪称体重，打印最重的小猪体重
	//访问数组中的每个元素，如果这个元素比我认定的最大值要大，更新最大值
	//1、创建5只小猪体重的数组
	int arr[5] = { 300,350,200,400,250 };
	//2、从数组中找到最大值
	int max = arr[0];
	for (int i = 1; i < 5; i++) {
		if (arr[i] > max) {
			max = arr[i];
		}
	}
	//3、打印最大值
	cout << "最大的小猪体重为：" << max << endl;
	return 0;
}

四、一维数组元素的逆置

int main() {
	//数组元素的逆置
	//1、创建数组
	int arr[5] = { 1,2,3,5,4 };
	cout << "数组逆置前" << endl;
	for (int i = 0; i < 5; i++)
	{
		cout << arr[i] << endl;
	}
	//2、实现逆置
	//2.1记录起始元素的下标
	int start = 0;
	//2.2记录结束下标位置
	int end = sizeof(arr) / sizeof(arr[0]) - 1;
	//2.3起始下标与结束下标的元素互换
	while (start < end)
	{
		int temp = arr[start];//临时变量
		arr[start] = arr[end];
		arr[end] = temp;
		//2.4起始位置++ 结束位置--
		start++;
		end--;
	}//2.5循环执行2.3操作,直至跳出循环

	//3、打印逆置后的数组
	cout << "数组元素逆置后：" << endl;
	for (int i = 0; i < 5; i++)
	{
		cout << arr[i] << endl;
	}
	return 0;
}

五、一维数组元素的冒泡排序

冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。

它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果顺序（如从大到小、首字母从Z到A）错误就把他们交换过来。走访元素的工作是重复地进行，直到没有相邻元素需要交换，也就是说该元素列已经排序完成。

这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。

冒泡排序算法的原理如下：

1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2. 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
3. 针对所有的元素重复以上的步骤，除了最后一个。
4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

int main() {
	//利用冒泡排序实现升序序列
	int arr[9] = { 4,2,8,0,5,7,1,3,9 };

	cout << "排序前" << endl;
	for (int i = 0; i < 9; i++)
	{
		cout << arr[i] << " ";
	}
	cout << endl;
	//开始冒泡排序
	//总共排序的轮数为元素的个数 - 1
	for (int i = 0; i < 9 - 1; i++)
	{
		//内层循环的对比 次数 = 元素个数-当前轮数-1
		for (int j = 0; j < 9 - i - 1; j++) {
			//如果第一个数字比第二个数字大，交换两个数字
			if (arr[j] > arr[j + 1])
			{
				int temp = arr[j];
				arr[j] = arr[j+1];
				arr[j+1] = temp;
			}
		}
	}
	cout << "排序后" << endl;
	for (int i = 0; i < 9; i++)
	{
		cout << arr[i] << " ";
	}
	cout << endl;
	return 0;
}

C++二维数组

二维数组本质上是以数组作为数组元素的数组，即“数组的数组”，类型说明符 数组名[常量表达式][常量表达式]。二维数组又称为矩阵，行列数相等的矩阵称为方阵。对称矩阵a[i][j] = a[j][i]，对角矩阵：n阶方阵主对角线外都是零元素。

一、二维数组的四种定义方式

1、数据类型 数组名【行数】【列数】;

int main() {
	//二维数组定义方式
	//1、数据类型 数组名【行数】【列数】;
	int arr[2][3];
	arr[0][0] = 1;
	arr[0][1] = 2;
	arr[0][2] = 3;
	arr[1][0] = 4;
	arr[1][1] = 5;
	arr[1][2] = 6;

	/*
	cout << arr[0][0] << endl;
	cout << arr[0][1] << endl;
	cout << arr[0][2] << endl;
	cout << arr[1][0] << endl;
	cout << arr[1][1] << endl;
	cout << arr[1][2] << endl;
	*/
	for (int i = 0; i < 2; i++)
	{
		for (int j = 0; j < 3; j++)
		{
			cout << arr[i][j] << endl;
		}
	}
	return 0;
}

2、数据类型 数组名【行数】【列数】 = {{数据1，数据2}，{数据3，数据4}};

int main() {
	//2、数据类型 数组名【行数】【列数】 = {{数据1，数据2}，{数据3，数据4}};
	int arr2[2][3] =
	{
		{1,2,3},
		{4,5,6}
	};
	return 0;
}

3、数据类型 数组名【行数】【列数】 = {数据1，数据2，数据3，数据4};

int main() {
	//二维数组定义方式
	//3、数据类型 数组名【行数】【列数】 = {数据1，数据2，数据3，数据4};
	int arr3[2][3] = { 1,2,3,4,5,6 };
	for (int i = 0; i < 2; i++)
	{
		for (int j = 0; j < 3; j++)
		{
			cout << arr3[i][j] << endl;
		}
	}
	return 0;
}

4、数据类型 数组名【】【列数】 = {数据1，数据2，数据3，数据4};

int main() {
	//4、数据类型 数组名【】【列数】 = {数据1，数据2，数据3，数据4};
	int arr4[][3] = { 1,2,3,4,5,6 };
	for (int i = 0; i < 2; i++)
	{
		for (int j = 0; j < 3; j++)
		{
			cout << arr4[i][j] << endl;
		}
	}
	return 0;
}

二、二维数组名称用途

1. 可以查看占用内存空间大小
2. 可以查看二维数组的首地址

int main() {
	//二维数组名称用途
	//1、可以查看占用内存空间大小
	int arr[2][3] =
	{
		{1,2,3},
		{4,5,6}
	};
	cout << "二维数组占用内存空间为：" << sizeof(arr) << endl;
	cout << "二维数组第一行占用内存为：" << sizeof(arr[0]) << endl;
	cout << "二维数组第一个元素占用内存为：" << sizeof(arr[0][0]) << endl;

	cout << "二维数组的行数为：" << sizeof(arr) / sizeof(arr[0]) << endl;
	cout << "二维数组的列数为：" << sizeof(arr[0]) / sizeof(arr[0][0]) << endl;

	//2、可以查看二维数组的首地址
	cout << "二维数组的首地址为："<<(int)arr << endl;
	cout << "二维数组第一行首地址为：" << (int)arr[0] << endl;
	cout << "二维数组第二行首地址为：" << (int)arr[1] << endl;
	cout << "二维数组第一个元素首地址为：" << (int)&arr[0][0] << endl;
	cout << "二维数组第二个元素首地址为：" << (int)&arr[0][1] << endl;
	return 0;
}

三、二维数组案例-考试成绩统计

int main() {
	//二维数组案例-考试成绩统计
	//1、创建二维数组，3行3列
	int scores[3][3] =
	{
		{100,100,100},
		{90,50,100},
		{60,70,80}
	};
	string name[3] = { "张三","李四","王五" };
	//2、统计考试成绩，让每行的3列相加，统计出总和
	for (int i = 0; i < 3; i++)
	{
		int sum = 0;
		for (int j = 0; j < 3; j++)
		{
			cout << scores[i][j] << " ";
			sum += scores[i][j];
		}
		cout << name[i] << "的总分为：" << sum << endl;
		cout << endl;
	}

	return 0;
}