当前位置：网站首页>数组相关知识

数组相关知识

2022-07-27 22:10:00 【徐憨憨！】

继学完函数相关知识之后，我们接下来学习数组的相关知识，我们都知道当我们定义一个整型变量时，会定义int a = 0，再定义一个整型变量时会定义int b = 0....当需要多个整型变量时，就会定义int类型的变量，但是同样的操作重复多次会显得代码十分冗杂，所以这里就引入了数组的定义，把多个相同类型的变量组合在一起便是数组！！！

目录：
1. 一维数组的创建和初始化
2. 一维数组的使用
3. 一维数组在内存中的存储
4. 二维数组的创建和初始化
5. 二维数组的使用
6. 二维数组在内存中的存储
7. 数组越界
8. 数组作为函数参数
9. 数组的应用实例1：三子棋
10. 数组的应用实例2：扫雷游戏

一· 一维数组

1.1 一维数组的创建

数组的创建方式：

type_t arr_name [const_n];
//type_t 是指数组的元素类型
//const_n 是一个常量表达式，用来指定数组的大小

示例：

int arr[10] = { 0 };//定义一个10个整型元素的数组，数组名为arr，数组内元素的类型时int类型

1.2 一维数组的初始化

数组的初始化分为完全初始化和不完全初始化，不完全初始化的时候，数组会根据数组的大小将剩下的元素默认为0，数组在创建的时候如果想不指定数组的确定的大小就得初始化，数组的元素个数根据初始化的内容来确定。

完全初始化：
int arr[4] = {1,2,3,4}//数组中有4个元素，分别为1 2 3 4
不完全初始化：
int arr[4] = {1,2}//数组中有4个元素，分别为1 2 0 0
未指定数组大小
int arr[] = {1,2,3,4}//数组根据初始化内容默认数组中有4个元素，分别为1 2 3 4
未指定数组大小且不初始化
int arr[] = {0}//默认数组中只有一个元素为0

字符型数组：

我们来看一段代码来思考一下其编译结果，从而加深对strlen的理解

#include <string.h>
int main()
{
	char arr1[] = "abcd";
	char arr2[] = { 'a','b','c','d' };
	char arr3[4] = { 'a','b','c','d' };
	char arr4[5] = { 'a','b','c','d' };
	printf("%d\n", strlen(arr1));
	printf("%d\n", strlen(arr2));
	printf("%d\n", strlen(arr3));
	printf("%d\n", strlen(arr4));

	return 0;
}

答案分别是：4 随机值随机值 4

对于arr1数组来说是一个字符串，默认结尾有一个‘\0',故为4

对于arr2数组来说，未指定数组大小，数组根据初始化内容来确定大小，为4个元素不包含‘\0'，故为随机值

对于arr3数组拉来说，定义的数组有4个元素不包含‘\0'，故结果为随机值

对于arr4数组来说，为不完全初始化，arr4[4] = ‘\0',故结果为4

调试结果如下：

1.3 一维数组的使用

分为输入和打印

int main()
{
	int arr[10] = 0;
	int i = 0;
	//输入
	for (i = 0; i < 10; i++)
	{
		scanf("%d", &arr[i]);
	}
	//打印
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");

	return 0;
}

总结:

1. 数组是使用下标来访问的，下标是从0开始。

2. 数组的大小可以通过计算得到。int sz = sizeof(arr)/sizeof(arr[0])

1.4 一维数组在内存中的存储

随着数组下标的增长，元素的地址，也在有规律的递增。由此可以得出结论：数组在内存中是连续存放的

二· 二维数组

2.1 二维数组的创建

int arr[2][3] = {0}//创建了一个两行三列，6个整型元素的数组

2.2 二维数组的初始化

同一维数组初始化一样，分为完全初始化和不完全初始化

int arr[3][4] = { 1,2,3,4};
int arr[3][4] = { { 1,2},{ 4,5}};
int arr[][4] = { { 2,3},{ 4,5}};

注意：二维数组如果有初始化，行可以省略，列不能省略

2.3 二维数组的使用

int main()
{
	int arr[3][4] = { 0 };
	int i = 0;
	//输入
	for (i = 0; i < 3; i++)
	{
		int j = 0;
		for (j = 0;j < 4; j++)
		{
			scanf("%d", &arr[i][j]);
		}
	}
	//打印
	for (i = 0; i < 3; i++)
	{
		int j = 0;
		for (j = 0;j < 4; j++)
		{
			printf("%d ", arr[i][j]);
		}
		printf("\n");
	}
	printf("\n");

	return 0;
}

2.4 二维数组在内存中的存储

同一维数组一样，递增

三· 数组越界

一个数组有n个元素时，数组下标从0开始，可以访问到n-1，当数组下标访问的时候小于0或者大于n-1时，机会越界访问。

四· 数组作为函数参数

数组作为函数参数时是如何传参与接收的，我将用一个冒泡排序算法给大家进行讲解

冒泡排序算法思想：
假如有n个元素我们需要从小到大将其排序时，n个元素我们需要排序n-1次，因为最后一个元素会自动排好序，每进行一次排序的时候，需要从第一个元素开始一次比较相邻两个元素的大小，不满足排序规则则需要进行交换，第一次排序需要交换n-1对元素，第二次交换需要交换n-2对元素......第j次排序则需要交换n-j对元素，所以在排序的函数内部需要嵌套两个循环。

void Bubble_sort(int arr[], int sz)
{
	//排序的趟数
	int i = 0;
	for (i = 0; i < sz - 1; i++)
	{
		//比较的对数
		int j = 0;
		for (j = 0; j < sz - 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[] = { 5,6,7,1,9,4,8,3,0,12 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	Bubble_sort(arr, sz);
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");

	return 0;
}

注意：

在上述代码中，数组元素的个数sz我们是把它当成参数传入函数中的，有的人会问为什么不在函数内部进行计算，这样在函数传参的时候不就会减少一个变量了嘛？其实这个原因在函数那个博客中我们也说明过。

因为数组传参时，传递的是首元素的地址，虽然接受的是int arr[],但是实际上它是一个指针变量，并非一个整型数组，既然它是一个指针变量，那么在函数内部计算sz的时候，sizeof（arr）,sizeof（arr[0])均表示首元素地址，sizeof（arr）/sizeof（arr[0]) = 1，这与我们定义的数组有10个变量就会矛盾。

那么数组名究竟是什么？我们来深入研究一下！

我们只需记住：

1. sizeof(数组名)，计算整个数组的大小，sizeof内部单独放一个数组名，数组名表示整个数

组。

2. &数组名，取出的是数组的地址。&数组名，数组名表示整个数组。

除此1,2两种情况之外，所有的数组名都表示数组首元素的地址。

示例：

//数组名表示数组首元素的地址，两种情况除外
//1.sizeof（数组名），表示整个数组所占用的空间大小，单位为字节
//2.&数组名，取出的是整个数组的地址，结果是数组第一个元素的地址，但是&数组名+1就会跳过整个数组的地址

int main()
{
	int arr[10] = { 0 };
	printf("%p\n", arr);
	printf("%p\n", arr + 1);

	printf("%p\n", &arr[0]);
	printf("%p\n", &arr[0] + 1);

	printf("%p\n", &arr);
	printf("%p\n", &arr+1);

	return 0;
}