【C语言步行梯】一维数组、二维数组介绍与应用详谈

🎯每日努力一点点，技术进步看得见
🏠专栏介绍：【C语言步行梯】专栏用于介绍C语言相关内容，每篇文章将通过图片+代码片段+网络相关题目的方式编写，欢迎订阅~~

---

为什么要有数组？

我给诸位设置个场景吧：现在有编号1到10000的小面包，此时需要保存这10000个小面包的重量，方便进行质量检测。如果没有数组会发生什么？

显然，定义10000个变量，键盘都快敲冒烟了。C语言这不就有了数组了吗？数组出马，一个顶千军万马。上面一万多行的代码，只要下面几行就能解决。

#include <stdio.h>
int main()
{
	double bread[10000] = {0};
	for(int i = 0; i < 10000; i++)
	{
		scanf("%lf", &bread[i]);
	}
}

一维数组

数组的创建

数组是一组相同类型元素的集合。 数组的创建方式如下：

type_name arr_name[size];
//type_name 表示 类型名称
//arr_name 表示 数组名称
//size 表示 数组大小

★ps：数组中的size一定要给常量才可以！

下面给出创建数组的示例：

#include <stdio.h>

int main()
{
	int arr1[10];	//定义一个包含100个int类型变量的数组
	double arr2[5];	//定义一个包含5个double类型变量的数组
	char arr3[100];	//定义其一个包含100个char类型变量的数组
	return 0;
}

数组的初始化

数组的初始化是指，在创建数组的同时给数组的内容一些合理初始值（初始化）。 看代码：

#include <stdio.h>
int main()
{
	int arr[5] = {1,2,3,4,5};
	return 0;
}

上面定义了一个整型数组，5个数组元素分别被初始化为1、2、3、4、5。这种将所有数组元素都初始化的情况，称为完全初始化。

#include <stdio.h>
int main()
{
	int arr[3] = {1, 2};
	return 0;
}

上面这份代码定义了一个包含3个元素的数组，前两个元素被初始化为1、2，最后一个元素没有初始化。对于这种没有完全初始化的情况，将其称为不完全初始化。对于不完全初始化的情况，没有初始化的元素会被自动初始化为0。

如果数组在创建的时候如果想不指定数组的确定的大小就得初始化。数组的元素个数根据初始化的内容来确定。

#include <stdio.h>
int main()
{
	int arr[] = {1,2,3,4,5};
	char ch[] = {'a', 'b', 'c'};
	return 0;
}

对于上面代码的两个数组，均没有指定数组的大小。arr数组因为其初始化数值有5个，故其数组大小为5；ch数组因为其初始化数值有3个，故其数组大小为3。

一维数组的使用

数组的下标是从0开始排列的。例如，创建一个int arr[4] = {1,2,3,4}的数组，则获取其中每个元素的下标的方法如下图所示↓↓↓

★ps：要获取下标为index的元素时，要使用数组名+[index]的方法。

下面代码演示：使用for循环打印arr数组的每个元素。

#include <stdio.h>

int main()
{
	int arr[5] = {1,2,3,4,5};
	for(int i = 0; i < 5; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
	return 0;
}

总结

1. 数组是使用下标来访问的，下标是从0开始。
2. 数组的大小可以通过sizeof(arr)/sizeof(arr[0])计算得到。

★ps：sizeof可以获取变量所占的空间大小。sizeof(arr)可以获取整个数组的大小，sizeof(arr[0])可以获取一个元素的大小，所以sizeof(arr)/sizeof(arr[0])可以计算出数组的大小。

一维数组在内存中的存储

我们通过打印数组每个元素的地址来看看一维数组存储规律↓↓↓

#include <stdio.h>

int main()
{
	int arr[10];
	for (int i = 0; i < 10; i++)
	{
		printf("&arr[i] = %p\n", &arr[i]);
	}
	return 0;
}

我们知道，每个int类型的元素占4个字节的空间。从上面的执行结果可以看到，上1元素的地址+4就是下一个元素的地址。说明数组是连续存放的。同时，数组的地址从小到大变化，说明数组是从低地址向高地址存储的。

二维数组

为啥要有二维数组呢？编号为0的同学语文考了100，数学考了90，英语考了80；编号为1的同学语文考了90，数学考了95，英语考了100…这时候，如果还用一维数组存储的话，就不太方便了。

如果我们使用二维数组，则可以将分数存储成下图所示的样子。↓↓↓
arr[0]可以获取第0号学生，arr[0][0]、arr[0][1]、arr[0][2]可以依次获取其语文、数学、英语成绩。

二维数组的创建

#include <stdio.h>

int main()
{
	int arr[2][3];
	return 0;
}

上面代码定义是一个2行3列的二维数组。我们可以这么理解二维数组：arr[2]表示定义2个一维数组，其中的3表示每个一维数组含有3个元素。

二维数组的初始化

#include <stdio.h>

int main()
{
	int arr[2][3] = {{1,2,3},{4,5,6}};
	int ch[2][3] = {{1,2},{4}};
	int tmp[2][3] = {1,2,3};
	return 0;
}

上面代码中arr数组每个元素都给了初始值。ch数组部分元素没有初始化，{{1,2},{4}}表示初始化ch[0][0]为1，ch[0][1]为2，ch[1][0]为4，余下元素被自动初始化为0。tmp数组也是部分元素没有初始化，{1,2,3}表示将tmp[0][0]、tmp[0][1]、tmp[0][2]分别初始化为0。

二维数组的使用

#include <stdio.h>

int main()
{
	int arr[2][3] = {0};
	for(int i = 0; i < 2; i++)
	{
		for(int j = 0; j < 3; j++)
		{
			arr[i][j] = i*j;
		}
	}
	for(int i = 0; i < 2; i++)
	{
		for(int j = 0; j < 3; j++)
		{
			printf("%d ", arr[i][j]);
		}
		printf("\n");
	}
	return 0;
}

二维数组的使用与一维数组的使用没有多大区别，只要给出对应的行、列下标即可访问。

二维数组在内存中的存储

我们和一维数组一样，通过打印每一个元素的数值，来观察内存规律。

#include <stdio.h>

int main()
{
	int arr[2][3] = {0};
	for(int i = 0; i < 2; i++)
	{
		for(int j = 0; j < 3; j++)
		{
			printf("&arr[%d][%d] = %p\n", i, j, &arr[i][j]);
		}
	}
	return 0;
}

我们可以发现每个元素地址差值都是4，说明二维数组也是连续存储的。也是从低地址向高地址存储。

数组名的含义

#include <stdio.h>

int main()
{
	int arr[6] = {1,2,3,4,5,6};
	printf("%p\n", arr);
	printf("%p\n", &arr[0]);
	printf("%d\n", *arr);
	return 0;
}

由上面程序结果可以知道，arr当中存储的就是首元素的地址，即&arr[0]。

但有两个例外的情况：

1. sizeof(arr)表示整个数组的大小，这里的arr表示整个数组。下面程序的输出结果为20（5个int元素，5×4=20）。

#include <stdio.h>

int main()
{
	int arr[5];
	printf("%d\n", sizeof(arr));
	return 0;
}

2. &arr，得到的数组的起始地址，这里的arr也表示整个数组。

数组的应用——冒泡排序

现在，我们5个无序元素{3,5,2,4,1}。如果arr[i]>arr[i+1]则交换这两个元素，那么会得到怎么样的结果呢？

通过这一番操作之后，最大值会到达最右侧。这时对除了5以外的4个元素再做这样的操作，将会得到第2大的数；再对除了5和4以外的3个元素做这样的操作，将会得到第3大的数；以此类推…
当只剩下一个元素时，则不再需要重复上述操作。

根据上面的分析，对于n个元素，我们需要进行n-1次从左到右的遍历、比较和交换操作。同时，每次从左到右的操作后，最后面都会多出一个已经有序的元素，故下一次遍历的时候，遍历边界要减少1。

#include <stdio.h>

int main()
{
	int arr[] = {3,5,2,4,1};
	int len = sizeof(arr)/sizeof(arr[0]);
	for(int i = 0; i < len - 1; i++)
	{
		for(int j = 0; j < len - 1 - i; j++)
		{
			if(arr[j] > arr[j + 1])
			{
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}
		}
	}

	for(int i = 0; i < len; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
	return 0;
}

如果此时要将冒泡排序封装为函数，则要将数组的长度传给该函数。因为数组传递给函数后，会退化为指针，sizeof(arr)的大小为指针的空间大小，不再是整个数组的大小。

#include <stdio.h>

void BubbleSort(int arr[], int len)
{
	for(int i = 0; i < len - 1; i++)
	{
		for(int j = 0; j < len - 1 - i; j++)
		{
			if(arr[j] > arr[j + 1])
			{
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}
		}
	}
}

int main()
{
	int arr[] = {3,5,2,4,1};
	int len = sizeof(arr)/sizeof(arr[0]);
	
	BubbleSort(arr, len);	

	for(int i = 0; i < len; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
	return 0;
}

🚩这篇文章结束了~~
如果文章中出现了错误，欢迎私信或留言。(๑•̀ㅂ•́)و✧
有任何疑问请评论或私信哦~~o(￣▽￣)ブ