[C++基础学习-04]----C++数组详解

前言

        在C++中，数组是一种用来存储相同类型元素的数据结构。一维数组是最简单的数组形式，它由一系列按顺序存储的元素组成。二维数组则是由一维数组构成的数组，可以看作是一堆一维数组堆叠在一起形成的矩阵。

正文

01-数组简介

         一维数组和二维数组是在编程中常用的数据结构，它们具有不同的特点和适用场景。

       1、一维数组：

        一维数组是一种线性结构，它由一系列按顺序存储的元素组成；通常用于存储一组相同类型的数据，例如整数、浮点数、字符等；访问速度比较快，通过数组下标即可快速定位和访问特定元素；适用于存储列表、向量、序列等线性数据。

        2、二维数组：

        二维数组是一种表格状的结构，它由一维数组组成的数组，用于存储表格数据或矩阵数据；通常用于存储二维结构的数据，例如游戏地图、图像数据、二维表格等；访问方式需要使用两个下标（行和列）来访问元素，适用于表示二维关系的数据；可以看作是一系列一维数组按照特定方式排列组成的数据结构。

        3、作用：

        一维数组常用于存储一组相关联的数据，例如存储学生成绩、温度记录、用户ID等。

        二维数组常用于表示二维空间上的数据，例如表示地图、图片、矩阵等。

        一维数组和二维数组在算法实现、数据处理、图形处理、矩阵运算等方面起着重要作用。

        通过合理使用一维数组和二维数组，可以更高效地组织和管理数据，方便进行各种数据处理和分析操作。

02-一维数组定义

         一维数组的定义和具体代码解释如下：

#include<iostream>
using namespace std;

int main()
{
	//数组   数组中每个数据元素都是相同的数据类型
	//三种表示形式
	//1、数据类型   数组名[数组长度]
    //2、数据类型   数组名[数组长度] = {值1、值2、....}
	//3、数据类型   数组名[ ] = {值1、值2、....}

	//1、数据类型 数组名[数组长度]
	int arr[5];//数组名用arr表示，长度为5个，数组下标从0开始
	//给数组中的元素进行赋值
	//牢记：数组元素的下标是从0开始索引的
	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;
	//循环方式输出数组中的数据
	//for (int i = 0; i < 5; i++)
	//{
	//	cout << arr[i] << endl;
	//}
	//2、数据类型   数组名[数组长度] = {值1、值2、....}
	//如果定义的数组长度为5个，但是后面赋值少于5个，则其余的自动取0
	int  arr2[5] = { 10,20,30,40,50 };
	
	//for (int j = 0; j < 5; j++)
	//{
	//	cout << arr2[j] << endl;
	//}
	//3、数据类型   数组名[ ] = {值1、值2、....}
	int arr3[] = { 10,20,30,40 };
	for (int j = 0; j < 4; j++)
	{
		cout << arr3[j] << endl;
	}
	system("pause");

	return 0;
}

03-数组名

         数组名的定义和具体代码解释如下：

#include<iostream>
using namespace std;

int main()
{
	//一维数组名称的用途
	//1、可以统计整个数组在内存中的长度
	int arr[5] = { 10,20,30,40,50 };
	cout << "数组在内存中所占的长度：" << sizeof(arr) << endl;
	cout << "第一个数据所占内存为:" << sizeof(arr[0]) << endl;
	cout << "数组中元素的个数为:" << sizeof(arr) / sizeof(arr[0]) << endl;
	//2、可以查看数组的首地址
	cout << "数组的首地址为:"<<(int)arr << endl;//加int，可将十六进制强制转换为十进制
	//也可查看第一个数据的首地址
	cout << "第一个数据的首地址为：" << (int)&arr[0] << endl;//第一个数据的首地址和数组的首地址是相同的
	cout << "第二个数据的首地址为:" << (int)&arr[1]<< endl;
	//数组名是一个常量，不可以再进行赋值操作
	// 常量不可进行修改，否则会出现表达式不可进行进行修改的左值
	//arr = 100;会出现报错
	system("pause");
	return 0;
}

04-一维数组案例

         一维数组的案例，三只小猪称体重具体代码解释如下：

#include<iostream>
using namespace std;

int main()
{
	//五只小猪比较体重
	//1、五只小猪的体重放入一个数组中
	int arr[5] = { 300,350,200,400,250 };
	//2、先假设一个最大值
	int max = 0;
	int max_pig = 0;
	for (int i = 0; i < 5;i++)
	{
		//cout << arr[i] << endl;
		if (arr[i] > max_pig)
		{
			max_pig = arr[i];
		}
		//cout << max_pig << endl;  如果在里面输出的话，不会跳出for循环，前面四个值也会进行输出，并且，不会比较250
	}
	cout << max_pig << endl;


// 	for (int i = 0; i < 5; i++)
// 	{
// 		if (arr[i] > max)
// 		//如果访问的数组中的元素比我认定的还要大，更新最大值，这是一个简单的算法
// 		{
// 			max = arr[i];	
// 		}
// 	}
// 	//要在循环之外输出最大值
//	cout<<max<<endl;

	system("pause");

	return 0;
}

05-一维数组之元素互换位置

         具体代码和解释如下：

#include<iostream>
using namespace std;

int main() 
{

	// 数组逆置

	// 1、创建数组
	int arr[5] = { 1,2,3,4,5 };

	cout << "数组逆置前的顺序： "<<endl;

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

		cout << arr[i] << endl;
	}
	
	// 2、数组逆置开始
	// 2.1 首先记录起始下表
	// 2.2 记录结束下表位置
	// 2.3 起始下表和结束下表的元素进行互换
	// 2.4 起始位置++，结束位置--
	// 2.5 循环执行2.1操作，直到起始位置>=结束位置
	int start = 0;  // 这里应该记录下表，而不应该直接记录数值
//	int temp = arr[start]; //这里就代表了将数组arr的第一个值存在了temp里 
	int end = sizeof(arr) / sizeof(arr[0]) - 1;  // 这里使用sizeof计算出了数组的总长度，然后将下表赋给end

	// 做一个while循环操作
	while(start<end)
	{
		// 实现元素互换
		int temp = arr[start];
		arr[start] = arr[end];
		arr[end] = temp;
		// 实现下表更新
		start++;
		end--;
	}

	// 打印输出互换之后的数据
	cout << "数组逆置后的顺序：" << endl;
	for (int j = 0; j < 5;j++)
	{
		cout << arr[j] << endl;
	}

	system("pause");
	return 0;
}

06-数组案例之冒泡排序

         具体代码和解释以及运行结果如下：

#include <iostream>
using namespace std;

void HeadAdjust(int Array[], int k, int len) {
	int temp = Array[k];// 最好别用哨兵的方法，直接找一个变量存储
	//这里一开始让i=根节点的左孩子位置，进入循环
	for (int i = 2 * k; i <= len; i *= 2) {
		//下面的这个循环就是在做一个元素下坠的操作，首先判断左孩子(i)是否小于右孩子11
		//若是小于，则i++，此时i指向右孩子，若是大于，不满足，继续指向左孩子
		if (i < len && Array[i] < Array[i + 1]) { i++; }
		//这里如果节点大于左孩子或者右孩子，其实这里就比较了一个，因为左孩子和右孩子的比较
		//在上一步条件语句中已经执行，这里比较之后，如果满足，证明节点值大，直接退出循环即可
		if (temp >= Array[i]) { break; }
		//若是不满足，则将孩子与节点位置互换，并且同时k向前移动，占据i的位置
		//这里如果还没有结束，可以继续循环，此时k又变成了下一个节点，继续上述步骤
		else { Array[k] = Array[i]; k = i; }
	}
	//当i > len时，全部执行完毕，退出循环，此时再将在哨兵位置保存的值赋给Array[k] 
	Array[k] = temp;
}

void swap(int &a, int &b) {
	int temp = a;
	a = b;
	b = temp;
}

void Heapsort(int Array[], int len) {
	for (int i = len / 2 - 1; i >= 0; i--) {
		HeadAdjust(Array, i, len);
	}
	//用1en-1是因为对数组来说是从0下标开始计数
	for (int i = len - 1; i > 0; i--) {
		swap(Array[i],Array[0]);
		//如果不封装，直接交换也可以
// 		int temp = Array[i];
// 		Array[i] = Array[0];
// 		Array[0] = temp;
		HeadAdjust(Array, 0, i - 1);
	}
}

int main()
{

	int arr[9] = { 4,2,8,0,5,7,1,9,3 };
	int len = sizeof(arr) / sizeof(arr[0]); 
	cout << "排序前数据：" << endl;
	for (int i = 0; i < len;i++)
	{
		cout << arr[i] << " ";
	}
	cout << endl;	

	Heapsort(arr, len);
	
	// 排序后结果
	cout << "排序后数据：" << endl;
	for (int i = 0; i < len; i++)
	{
		cout << arr[i] << " ";
	}
	cout << endl;

	system("pause");
	return 0;

}

07-二维数组定义

         具体代码和解释如下：

#include<iostream>
using namespace std;

int main() 
{
	// 二维数组定义方式
	/*
	1. 数据类型 数组名[ 行数 ][ 列数 ];
	2. 数据类型 数组名[ 行数 ][ 列数 ] = { {数据1，数据2 } ，{数据3，数据4 } };
	3. 数据类型 数组名[ 行数 ][ 列数 ] = { 数据1，数据2，数据3，数据4};
	4. 数据类型 数组名[ ][ 列数 ] = { 数据1，数据2，数据3，数据4};
	建议：以上4种定义方式，利用==第二种更加直观，提高代码的可读性
	*/
	//1. 数据类型 数组名[ 行数 ][ 列数 ];
	int arr[2][3];
	// 赋值
	arr[0][0] = 25; //第0行第1列的数据为25
	arr[0][1] = 26;
	arr[0][2] = 27;
	arr[1][0] = 28;
	arr[1][1] = 29;
	arr[1][2] = 30;

	// 使用嵌套循环进行打印数组
	// 外层循环打印行数，内层循环打印列数
// 	for (int i = 0; i < 2; i++)
// 	{
// 		for (int j = 0; j < 3;j++)
// 		{
// 			cout << arr[i][j] << endl;
// 		}
// 	}


	//2. 数据类型 数组名[ 行数 ][ 列数 ] = { {数据1，数据2 } ，{数据3，数据4 } };  推荐
	int arr2[2][3] = { {1,2,3},{4,5,6} };  // 这样显示更加直观
	for (int i = 0; i < 2; i++)
	{
		for (int j = 0; j < 3; j++)
		{
			cout << arr2[i][j] << " ";
		}
		cout << endl;
	}
	
	//方式3
	//数据类型 数组名[行数][列数] = { 数据1，数据2 ,数据3，数据4 };
	int arr3[2][3] = { 1,2,3,4,5,6 };

	//方式4
	//数据类型 数组名[][列数] = { 数据1，数据2 ,数据3，数据4 };
	int arr4[][3] = { 1,2,3,4,5,6 };


	system("pause");
	return 0;

}

08-二维数组之数组名

         具体代码和解释如下：

#include <iostream>
using namespace std;

int main()
{

	// 二维数组名称的用途

	// 1、可以查看占用内存空间大小

	int arr[2][3] = 
	{
		{1,2,3},
		{4,5,5}
	};
	cout << "二维数组占用内存空间：" << sizeof(arr) << endl;  // 24 6*4
	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[0][0] << endl;
	cout << "二维数组第二行的首地址为：" << (int)arr[1] << endl;


	system("pause");
	return 0;

}

09-二维数组案例成绩统计

         具体代码和解释如下：

#include <iostream>
using namespace std;
#include <string>
int main()
{

    // 二维数组的案例-考试成绩统计
	int scores[3][3] =
	{
		{ 100,100,100 },
		{ 90, 50, 100 },
		{ 60, 70,  80}
	};

	string names[3] = { "张三","李四","王五" }; //这相当于又定义了一个名字的一维数组
	// 2、统计每个学生分数总分
	for (int i = 0; i < 3;i++)
	{

		int sum = 0;
		for (int j = 0; j < 3;j++ )
		{
			sum += scores[i][j];
			// cout << num << " ";
		}
		cout<< names[i] <<"的总分为："<<sum<<endl;
	}

	system("pause");
	return 0;

}

总结

         一维数组是一列元素的集合，而二维数组是由多行多列元素组成的矩阵。在C++中，使用数组可以方便地存储和处理大量数据，同时可以通过下标访问数组元素来实现对数组的操作和处理。一维数组和二维数组是编程中常用的数据结构，它们具有各自的特点和适用场景，可以帮助程序员有效地处理各种类型的数据。