前言
在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++中，使用数组可以方便地存储和处理大量数据，同时可以通过下标访问数组元素来实现对数组的操作和处理。一维数组和二维数组是编程中常用的数据结构，它们具有各自的特点和适用场景，可以帮助程序员有效地处理各种类型的数据。
