devbox
从前慢现在也慢
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

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

作者：从前慢现在也慢 | 2024-05-04 22:29:00

赞

踩

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

前言

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

正文

01-数组简介

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

       1、一维数组：

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

        2、二维数组：

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

        3、作用：

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

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

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

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

02-一维数组定义

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

  1. #include<iostream>
  2. using namespace std;
  3.  
  4. int main()
  5. {
  6. 	//数组   数组中每个数据元素都是相同的数据类型
  7. 	//三种表示形式
  8. 	//1、数据类型   数组名[数组长度]
  9.     //2、数据类型   数组名[数组长度] = {值1、值2、....}
  10. 	//3、数据类型   数组名[ ] = {值1、值2、....}
  11.  
  12. 	//1、数据类型 数组名[数组长度]
  13. 	int arr[5];//数组名用arr表示，长度为5个，数组下标从0开始
  14. 	//给数组中的元素进行赋值
  15. 	//牢记：数组元素的下标是从0开始索引的
  16. 	arr[0] = 10;
  17. 	arr[1] = 20;
  18. 	arr[2] = 30;
  19. 	arr[3] = 40;
  20. 	arr[4] = 50;
  21. 	//访问数据元素
  22. 	//cout << arr[0] << endl;
  23. 	//cout << arr[1] << endl;
  24. 	//cout << arr[2] << endl;
  25. 	//cout << arr[3] << endl;
  26. 	//cout << arr[4] << endl;
  27. 	//循环方式输出数组中的数据
  28. 	//for (int i = 0; i < 5; i++)
  29. 	//{
  30. 	//	cout << arr[i] << endl;
  31. 	//}
  32. 	//2、数据类型   数组名[数组长度] = {值1、值2、....}
  33. 	//如果定义的数组长度为5个，但是后面赋值少于5个，则其余的自动取0
  34. 	int  arr2[5] = { 10,20,30,40,50 };
  35. 	
  36. 	//for (int j = 0; j < 5; j++)
  37. 	//{
  38. 	//	cout << arr2[j] << endl;
  39. 	//}
  40. 	//3、数据类型   数组名[ ] = {值1、值2、....}
  41. 	int arr3[] = { 10,20,30,40 };
  42. 	for (int j = 0; j < 4; j++)
  43. 	{
  44. 		cout << arr3[j] << endl;
  45. 	}
  46. 	system("pause");
  47.  
  48. 	return 0;
  49. }

03-数组名

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

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

04-一维数组案例

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

  1. #include<iostream>
  2. using namespace std;
  3.  
  4. int main()
  5. {
  6. 	//五只小猪比较体重
  7. 	//1、五只小猪的体重放入一个数组中
  8. 	int arr[5] = { 300,350,200,400,250 };
  9. 	//2、先假设一个最大值
  10. 	int max = 0;
  11. 	int max_pig = 0;
  12. 	for (int i = 0; i < 5;i++)
  13. 	{
  14. 		//cout << arr[i] << endl;
  15. 		if (arr[i] > max_pig)
  16. 		{
  17. 			max_pig = arr[i];
  18. 		}
  19. 		//cout << max_pig << endl;  如果在里面输出的话，不会跳出for循环，前面四个值也会进行输出，并且，不会比较250
  20. 	}
  21. 	cout << max_pig << endl;
  22.  
  23.  
  24. // 	for (int i = 0; i < 5; i++)
  25. // 	{
  26. // 		if (arr[i] > max)
  27. // 		//如果访问的数组中的元素比我认定的还要大，更新最大值，这是一个简单的算法
  28. // 		{
  29. // 			max = arr[i];	
  30. // 		}
  31. // 	}
  32. // 	//要在循环之外输出最大值
  33. //	cout<<max<<endl;
  34.  
  35. 	system("pause");
  36.  
  37. 	return 0;
  38. }

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

         具体代码和解释如下：

  1. #include<iostream>
  2. using namespace std;
  3.  
  4. int main() 
  5. {
  6.  
  7. 	// 数组逆置
  8.  
  9. 	// 1、创建数组
  10. 	int arr[5] = { 1,2,3,4,5 };
  11.  
  12. 	cout << "数组逆置前的顺序： "<<endl;
  13.  
  14. 	for (int i = 0; i < 5;i++)
  15. 	{
  16.  
  17. 		cout << arr[i] << endl;
  18. 	}
  19. 	
  20. 	// 2、数组逆置开始
  21. 	// 2.1 首先记录起始下表
  22. 	// 2.2 记录结束下表位置
  23. 	// 2.3 起始下表和结束下表的元素进行互换
  24. 	// 2.4 起始位置++，结束位置--
  25. 	// 2.5 循环执行2.1操作，直到起始位置>=结束位置
  26. 	int start = 0;  // 这里应该记录下表，而不应该直接记录数值
  27. //	int temp = arr[start]; //这里就代表了将数组arr的第一个值存在了temp里 
  28. 	int end = sizeof(arr) / sizeof(arr[0]) - 1;  // 这里使用sizeof计算出了数组的总长度，然后将下表赋给end
  29.  
  30. 	// 做一个while循环操作
  31. 	while(start<end)
  32. 	{
  33. 		// 实现元素互换
  34. 		int temp = arr[start];
  35. 		arr[start] = arr[end];
  36. 		arr[end] = temp;
  37. 		// 实现下表更新
  38. 		start++;
  39. 		end--;
  40. 	}
  41.  
  42. 	// 打印输出互换之后的数据
  43. 	cout << "数组逆置后的顺序：" << endl;
  44. 	for (int j = 0; j < 5;j++)
  45. 	{
  46. 		cout << arr[j] << endl;
  47. 	}
  48.  
  49. 	system("pause");
  50. 	return 0;
  51. }

06-数组案例之冒泡排序

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

  1. #include <iostream>
  2. using namespace std;
  3.  
  4. void HeadAdjust(int Array[], int k, int len) {
  5. 	int temp = Array[k];// 最好别用哨兵的方法，直接找一个变量存储
  6. 	//这里一开始让i=根节点的左孩子位置，进入循环
  7. 	for (int i = 2 * k; i <= len; i *= 2) {
  8. 		//下面的这个循环就是在做一个元素下坠的操作，首先判断左孩子(i)是否小于右孩子11
  9. 		//若是小于，则i++，此时i指向右孩子，若是大于，不满足，继续指向左孩子
  10. 		if (i < len && Array[i] < Array[i + 1]) { i++; }
  11. 		//这里如果节点大于左孩子或者右孩子，其实这里就比较了一个，因为左孩子和右孩子的比较
  12. 		//在上一步条件语句中已经执行，这里比较之后，如果满足，证明节点值大，直接退出循环即可
  13. 		if (temp >= Array[i]) { break; }
  14. 		//若是不满足，则将孩子与节点位置互换，并且同时k向前移动，占据i的位置
  15. 		//这里如果还没有结束，可以继续循环，此时k又变成了下一个节点，继续上述步骤
  16. 		else { Array[k] = Array[i]; k = i; }
  17. 	}
  18. 	//当i > len时，全部执行完毕，退出循环，此时再将在哨兵位置保存的值赋给Array[k] 
  19. 	Array[k] = temp;
  20. }
  21.  
  22. void swap(int &a, int &b) {
  23. 	int temp = a;
  24. 	a = b;
  25. 	b = temp;
  26. }
  27.  
  28. void Heapsort(int Array[], int len) {
  29. 	for (int i = len / 2 - 1; i >= 0; i--) {
  30. 		HeadAdjust(Array, i, len);
  31. 	}
  32. 	//用1en-1是因为对数组来说是从0下标开始计数
  33. 	for (int i = len - 1; i > 0; i--) {
  34. 		swap(Array[i],Array[0]);
  35. 		//如果不封装，直接交换也可以
  36. // 		int temp = Array[i];
  37. // 		Array[i] = Array[0];
  38. // 		Array[0] = temp;
  39. 		HeadAdjust(Array, 0, i - 1);
  40. 	}
  41. }
  42.  
  43. int main()
  44. {
  45.  
  46. 	int arr[9] = { 4,2,8,0,5,7,1,9,3 };
  47. 	int len = sizeof(arr) / sizeof(arr[0]); 
  48. 	cout << "排序前数据：" << endl;
  49. 	for (int i = 0; i < len;i++)
  50. 	{
  51. 		cout << arr[i] << " ";
  52. 	}
  53. 	cout << endl;	
  54.  
  55. 	Heapsort(arr, len);
  56. 	
  57. 	// 排序后结果
  58. 	cout << "排序后数据：" << endl;
  59. 	for (int i = 0; i < len; i++)
  60. 	{
  61. 		cout << arr[i] << " ";
  62. 	}
  63. 	cout << endl;
  64.  
  65. 	system("pause");
  66. 	return 0;
  67.  
  68. }

07-二维数组定义

         具体代码和解释如下：

  1. #include<iostream>
  2. using namespace std;
  3.  
  4. int main() 
  5. {
  6. 	// 二维数组定义方式
  7. 	/*
  8. 	1. 数据类型 数组名[ 行数 ][ 列数 ];
  9. 	2. 数据类型 数组名[ 行数 ][ 列数 ] = { {数据1，数据2 } ，{数据3，数据4 } };
  10. 	3. 数据类型 数组名[ 行数 ][ 列数 ] = { 数据1，数据2，数据3，数据4};
  11. 	4. 数据类型 数组名[ ][ 列数 ] = { 数据1，数据2，数据3，数据4};
  12. 	建议：以上4种定义方式，利用==第二种更加直观，提高代码的可读性
  13. 	*/
  14. 	//1. 数据类型 数组名[ 行数 ][ 列数 ];
  15. 	int arr[2][3];
  16. 	// 赋值
  17. 	arr[0][0] = 25; //第0行第1列的数据为25
  18. 	arr[0][1] = 26;
  19. 	arr[0][2] = 27;
  20. 	arr[1][0] = 28;
  21. 	arr[1][1] = 29;
  22. 	arr[1][2] = 30;
  23.  
  24. 	// 使用嵌套循环进行打印数组
  25. 	// 外层循环打印行数，内层循环打印列数
  26. // 	for (int i = 0; i < 2; i++)
  27. // 	{
  28. // 		for (int j = 0; j < 3;j++)
  29. // 		{
  30. // 			cout << arr[i][j] << endl;
  31. // 		}
  32. // 	}
  33.  
  34.  
  35. 	//2. 数据类型 数组名[ 行数 ][ 列数 ] = { {数据1，数据2 } ，{数据3，数据4 } };  推荐
  36. 	int arr2[2][3] = { {1,2,3},{4,5,6} };  // 这样显示更加直观
  37. 	for (int i = 0; i < 2; i++)
  38. 	{
  39. 		for (int j = 0; j < 3; j++)
  40. 		{
  41. 			cout << arr2[i][j] << " ";
  42. 		}
  43. 		cout << endl;
  44. 	}
  45. 	
  46. 	//方式3
  47. 	//数据类型 数组名[行数][列数] = { 数据1，数据2 ,数据3，数据4 };
  48. 	int arr3[2][3] = { 1,2,3,4,5,6 };
  49.  
  50. 	//方式4
  51. 	//数据类型 数组名[][列数] = { 数据1，数据2 ,数据3，数据4 };
  52. 	int arr4[][3] = { 1,2,3,4,5,6 };
  53.  
  54.  
  55. 	system("pause");
  56. 	return 0;
  57.  
  58. }

08-二维数组之数组名

         具体代码和解释如下：

  1. #include <iostream>
  2. using namespace std;
  3.  
  4. int main()
  5. {
  6.  
  7. 	// 二维数组名称的用途
  8.  
  9. 	// 1、可以查看占用内存空间大小
  10.  
  11. 	int arr[2][3] = 
  12. 	{
  13. 		{1,2,3},
  14. 		{4,5,5}
  15. 	};
  16. 	cout << "二维数组占用内存空间：" << sizeof(arr) << endl;  // 24 6*4
  17. 	cout << "二维数组第一行所占内存：" << sizeof(arr[0]) << endl;   
  18. 	cout << "二维数组第一个元素所占内存：" << sizeof(arr[0][0]) << endl;
  19.  
  20. 	// 通过总的二维数组所占内存空间，以及每一行所占内存空间，可以计算得到该数组共有多少行
  21. 	cout << "二维数组的总行数：" << sizeof(arr) / sizeof(arr[0]) << endl;
  22.  
  23. 	// 通过总的二维数组每一行所占内存空间，以及每个元素所占内存空间，可以计算得到该数组每一行有多少个元素
  24. 	cout << "二维数组每一行元素个数或者可以说有多少列：" << sizeof(arr[0]) / sizeof(arr[0][0]) << endl;
  25.  
  26. 	// 2、二位数组的首地址
  27. 	cout << "二维数组的首地址为：" << (int)arr << endl;
  28. 	cout << "二维数组第一行的首地址为：" << (int)arr[0] << endl;
  29. 	// 当访问具体元素的地址时，一定不要忘记加上取地址的符号
  30. 	cout << "二维数组第一个元素的首地址为：" << (int)&arr[0][0] << endl;
  31. 	cout << "二维数组第二行的首地址为：" << (int)arr[1] << endl;
  32.  
  33.  
  34. 	system("pause");
  35. 	return 0;
  36.  
  37. }

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

         具体代码和解释如下：

  1. #include <iostream>
  2. using namespace std;
  3. #include <string>
  4. int main()
  5. {
  6.  
  7.     // 二维数组的案例-考试成绩统计
  8. 	int scores[3][3] =
  9. 	{
  10. 		{ 100,100,100 },
  11. 		{ 90, 50, 100 },
  12. 		{ 60, 70,  80}
  13. 	};
  14.  
  15. 	string names[3] = { "张三","李四","王五" }; //这相当于又定义了一个名字的一维数组
  16. 	// 2、统计每个学生分数总分
  17. 	for (int i = 0; i < 3;i++)
  18. 	{
  19.  
  20. 		int sum = 0;
  21. 		for (int j = 0; j < 3;j++ )
  22. 		{
  23. 			sum += scores[i][j];
  24. 			// cout << num << " ";
  25. 		}
  26. 		cout<< names[i] <<"的总分为："<<sum<<endl;
  27. 	}
  28.  
  29. 	system("pause");
  30. 	return 0;
  31.  
  32. }

总结

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

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/从前慢现在也慢/article/detail/536382
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号