数组的介绍

1. 数组的概念

数组就是一组同类型的元素的集合，数组中的元素至少为1个或多个。

2. 一维数组的创建和初始化

2.1 数组的创建

type name[常量值]；

这是数组的标准写法，数组在创建时可以指定数组类型、数组名、数组大小。

type：指的是数组中存放元素的类型，可以是：char、int、float、double等，也可以是自定义类型。
name：是数组的名字，根据情况而定，写的有意义即可。
[]：中的常量值，指的是你想要指定的数组大小，可以是常量或常量表达式。

2.2 数组的初始化

在VS中数组的使用必须初始化，不然是不允许使用的。

int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };

这是完全初始化，代表数组中每一个元素都是你确定的值。

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

这是不完全初始化，代表数组中元素只确定几个值，其余元素默认为0。

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

这种也是完全初始化，但其不写数组大小。这会使得数组大小，完全由{}中元素的个数来确定。

2.3 数组的类型

以下方语句为例：

int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };

这个数组的类型是int[10]，等号前的部分去掉数组名就是数组的类型，数组类型是自定义类型，它不是C语言的内置类型
注意，有人认为int是数组的类型，其实int是数组中元素的类型。

3. 一维数组的使用

3.1 数组的下标

数组的下标从0开始，假设数组有n个元素，那么最后一个元素的下标就是n-1，下标相当于数组中元素的编号。

int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };

在C语言中为数组的访问提供了一个操作符[]，这个操作符叫：下标引用操作符。
有了下标引用操作符，和数组中元素的下标，我们就可以定向访问数组中的元素。
例如：我想要把4打印出来，4在数组中的下标是3，可以这样写。

#include <stdio.h>
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	printf("%d\n", arr[3]);
	return 0;
}

3.2 数组的打印

知道了怎么访问数组中单个元素，那整个数组的打印又怎么办呢？
想要访问数组中的元素，就要知道是数组中的下标，所以可以使用循环，使数组的下标动起来。

#include <stdio.h>
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int i = 0;
	for (i = 0; i < 10; ++i)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
	return 0;
}

3.3 数组的输入

向数组中输入数据要知道数组的下标，我们可以用循环来产生不同的下标。

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
int main()
{
	int i = 0;
	int arr[10] = { 0 };
	for (i = 0; i < 10; ++i)
	{
		scanf("%d", &arr[i]);
	}
	for (i = 0; i < 10; ++i)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

使用scanf()函数时要加&，这是因为此时的arr[i]代表下标为i的元素，不是地址，而scanf()函数需要的的是地址，所以要取地址。

4. 一维数组在内存中的存储

我们用循环打印出数组中的元素地址，如下：

#include <stdio.h>
int main()
{
	int i = 0;
	int arr[10] = { 0 };
	for (i = 0; i < 10; ++i)
	{
		printf("arr[%d] = %p\n", i, &arr[i]);
	}
	return 0;
}

十六进制数字( 0，1，2，3，4，5，6，7，8，9，A，C，D，E，F )
可以看到数组中每个元素的地址之间相差4个字节，而整形大小是4字节，由此得出示数组元素在内存中是连续存储的。

5. sizeof计算数组元素的个数

数组元素简明时我们可以一眼看出数组的大小，但当数组很大很复杂时，就要用sizeof来计算数组大小。

sizeof是一个操作符，他计算的是类型或表达式的大小，单位是字节。

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	printf("%zd\n", sizeof(arr));
	return 0;
}

可以看到arr数组的大小是40字节。

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	printf("%zd\n", sizeof(arr[0]));
	return 0;
}

这是数组中单个元素的大小

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	printf("%zd\n", sizeof(arr)/sizeof(arr[0]));
	return 0;
}

我们用数组的总大小除以数组中单个元素的大小就得到了数组的元素个数。

6. 二维数组的概念

6.1 二维数组的概念

一维数组是以C语言中的内置类型为元素，二维数组是以一维数组为元素的数组，三维数组是以二维数组为元素的数组，我们把二维数组以上的数组称为多维数组。

整型、整型一维数组、整型二维数组

6.2 二维数组的创建

二维数组的标准语法：

type name[常量1][常量2];

例如：
int arr[3][5];
double date[3][7];

以arr数组为例：

int：这是二维数组的中的元素类型。
arr：这是数组的名字，由你指定。
3：表示数组有3行。
5：表示数组一行有5个元素。

7. 二维数组的初始化

在创建变量和数组时，人为的给定一些初始值，称为初始化。

7.1 不完全初始化

int arr1[3][5] = { 1,2,3 };
int arr2[3][5] = { 0 };

这里全是0的原因不是数组完全初始化了，而是不完全初始化时，编译器会把其他元素默认初始化为0。

7.2 完全初始化

int arr3[3][5] = { 1,2,3,4,5,2,3,4,5,6,3,4,5,6,7 };

7.3 按照行初始化

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

int arr5[3][5] = { {1,2,3,4,5},{2,3,4,5,6},{3,4,5,6,7} };

7.4 初始化时省略行，但不能省略列

int arr6[][5] = { 1,2,3 };
int arr7[][5] = { 1,2,3,4,5,6 };
int arr8[][5] = { {1,2,3},{2,3,4},{3,4,5} };

8. 二维数组的使用

8.1 二维数组的下标

二维数组的下标有行和列，所以只要同时确定行和列，才就能锁定数组中唯一的元素。
二维数组的行从0开始，列也从0开始

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

黄色的的数字是数组的行数，蓝色的数字是数组的列数。

如果我们想访问二维数组中的第3行第4列的元素：

#include <stdio.h>
int main()
{
	int arr[3][5] = { 1,2,3,4,5, 2,3,4,5,6, 3,4,5,6,7 };
	printf("%d\n", arr[2][3]);
	return 0;
}

8.2 二维数组的输入与输出

知道了如何访问二维数组的单个元素，那如何访问整个数组呢？其实和访问但个元素相似，只要能够产生数组中所有元素的下标，就可以访问整个数组。

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
int main()
{
	int arr[3][5] = { 0 };
	int i = 0;
	//输入
	for (i = 0; i < 3; ++i)//产生行号
	{
		int j = 0;
		for (j = 0; j < 5; ++j)//产生列号
		{
			scanf("%d", &arr[i][j]);
		}
	}
	//输出
	for (i = 0; i < 3; ++i)//产生行号
	{
		int j = 0;
		for (j = 0; j < 5; ++j)//产生列号
		{
			printf("%d ", arr[i][j]);
		}
		printf("\n");
	}
	return 0;
}

9. 二维数组在内存中的存储

打印二维数组的地址

#include <stdio.h>
int main()
{
	int arr[3][5] = { 0 };
	int i = 0;
	for (i = 0; i < 3; ++i)//产生行号
	{
		int j = 0;
		for (j = 0; j < 5; ++j)//产生列号
		{
			printf("&arr[%d][%d] = %p\n", i, j, &arr[i][j]);
		}
	}
	return 0;
}

可以看到每一个元素的地址都是相差4个字节，跨行位置处的元素也是如此（ 例如：arr[0][4]和arr[1][0] )，所以二维数组的每个元素在内存中都是连续存放的

如下图所示：

10. C99的变长数组

在C99之前，C语言在创建数组时，数组大小只能使用常量和常量表达式，或者在初始化时省略数组大小。

例如：

int arr1[10];
int arr2[3 + 5];
int arr3[] = { 1,2,3 };

这样的语法限制，会在我们创建数组时不够灵活，有时数组大了浪费空间，有时数组小了不够用。

C99中添加了一个变长数组的语法，允许我们可以使用变量来指定数组大小。

例如：

int n = a + b;
int arr[n];

上面示例中，数组arr就是变长数组，因为它的长度取决于变量n的值，编译器没法事先确定，只有运行时才能知道n是多少。
变长数组的根本特征，就是数组长度只有运行时才能确定，所以变长数组不能初始化。它的好处是程序员不必在开发时，随意为数组指定一个估计的长度，程序可以在运行时为数组分配精确的长度。

有一个容易迷惑点，变长数组的意思是数组的大小是可以使用变量来指定的，在程序运行的时候，根据变量的大小来指定数组的元素个数，而不是说数组的大小是可变的。数组的大小一旦确定就不能再变化了。
在VS2022上，虽然支持大部分C99的语法，没有支持C99中的变长数组，没法测试。有兴趣可以在支持变长数组的编译器中试验以下代码。

#include <stdio.h>
int main()
{
	int n = 0;
	scanf("%d", &n);
	int arr[n];
	int i = 0;
	for (i = 0; i < n; ++i)
	{
		scanf("%d", &arr[i]);
	}
	for (i = 0; i < n; ++i)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

11. 数组练习

练习1：多个字符从两端移动，像中间汇聚

#include <stdio.h>
int main()
{
	char arr1[] = "Hello new world";
	char arr2[] = "###############";
	int left = 0;
	int right = strlen(arr1) - 1;
	printf("%s\n", arr2);
	while (left <= right)
	{
		Sleep(1000);
		arr2[left] = arr1[left];
		arr2[right] = arr1[right];
		left++;
		right--;
		printf("%s\n", arr2);
	}
	return 0;
}

练习2：二分查找

查找一个有序数组中元素的下标，最容易想到的是从头都尾一个一个找，但当数组中的元素非常多时，这样的方法就会非常的浪费时间。那就需要一个节省时间的方法。

#include <stdio.h>
int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	int left = 0;
	int right = sizeof(arr) / sizeof(arr[0]) - 1;
	int key = 7;//要找的数字
	int mid = 0;
	int find = 0;
	while (left <= right)
	{
		mid = (left + right) / 2;
		if (arr[mid] > key)
		{
			right = mid - 1;
		}
		else if (arr[mid] < key)
		{
			left = mid + 1;
		}
		else
		{
			find = 1;
			break;
		}
	}
	if (1 == find)
		printf("找到了，下标是%d\n", mid);
	else
		printf("找不到\n");
	return 0;
}

求中间元素的下标时，使用mid=(left+right)/2，如果left和right过大时可能存在溢出问题。可以用以下方式来求中间元素坐标。

mid = left + (right - left) / 2;