- 数组是一组相同类型元素的集合
- 数组中存放的是1个或者多个数据，但是数组元素个数不能为0
- 数组中存放的多个数据，类型是相同的
- 数组分为一维数组和多维数组，多维数组一般比较多见的是二维数组
- 存放在数组中的值被称为数组的元素，数组在创建的时候可以指定数组的大小和数组的元素类型
一：一维数组
1.一维数组的创建：
语法格式：
type arr_name[常量值];
type：指定的是数组中存放数据的类型，可以是char；short；int；float等，也可以是自定义类型arr_name：指的是数组的名字[]：包裹的是常量值，用来指定数组的大小的；在C99标准之前定义数组的大小只能是由常量指定，不能使用变量。
示例：创建一个数组
int math[10]; //创建一个长度为10，int类型的数组元素
char people[3]; //创建一个长度为3，char类型的数组元素
double English[14]; //创建一个长度为14，double类型的数组元素
2.一维数组的初始化
数组在创建的时候，我们有时会根据一些实际的需求给定一些初始值，这就叫初始化；数组的初始化一般是使用大括号将数据包裹在其中。
示例：数组初始化
//完全初始化
int arr1[5] = {
1,2,3,4,5}; //这里指的是数组的元素类型为int
//不完全初始化
int arr2[6] = {
1}; //第一个元素的初始化为1，剩余的元素默认初始化为0
//错误的初始化 -- 初始化项过多
int arr3[4] = {
1,2,3,4,5};
//如果数组初始化了，是可以省略掉数组的大小的；数组的大小，是编译器根据初始化的内容确定的
int arr4[] = {
1,2,3}; //此时数组的大小为3
注意： 数组也是有类型的，数组算是一种自定义类型，去掉数组名留下的就是当前数组的类型
3.一维数组的使用
C语言规定数组是有下标的，下标从0开始，假设数组有n个元素，那么最后一个元素的下标就是n-1，下标就相当于是对数组元素的编号
示例：
//定义一个int类型的数组
int arr5[12] = {
1,2,3,4,5,6,7,8,9,10,11,12};
图解：
在C语言中为数组的访问提供了一个操作符[]，这个操作符叫做下标引用操作符
示例：
#include <stdio.h>
int main()
{
//定义一个int类型的数组
int arr5[12] = {
1,2,3,4,5,6,7,8,9,10,11,12};
//访问下标为7的元素（也就是8）
printf("%d\n",arr5[7]);
return 0;
}
示例：通过下标打印所有元素（数组的输出）
#include <stdio.h>
int main()
{
//定义一个int类型的数组
int arr5[12] = {
1,2,3,4,5,6,7,8,9,10,11,12};
//通过下标打印所有元素
int i = 0;
for(i=0;i<12;i++)
{
printf("%d ",arr5[i]);
}
return 0;
}
示例：给数组输入自己想要的数据（数组的输入）
#include <stdio.h>
int main()
{
//定义一个int类型的数组
int arr5[12] = {
1,2,3,4,5,6,7,8,9,10,11,12};
//输入
int i = 0;
for(i=0;i<12;i++)
{
scanf("%d",&arr5[i]);
}
return 0;
}
4.一维数组在内存中的存储
示例：依次打印数组元素的内存地址
#include <stdio.h>
int main()
{
int arr[5] = {
1,2,3,4,5};
int i = 0;
for(i=0;i<5;i++)
{
printf("&arr[%d] = %p\n",i,&arr[i]); //打印地址的占位符是%p
}
return 0;
}
从输出结果可以看出，数组随着下标的增长，地址是由低到高变化的，并且每两个相邻的元素之间相差为4（因为1个int整型是4个字节）；所以得出一个结论：数组在内存中是连续存放的。
5.sizeof()计算元素个数
sizeof() 是C语言中的一个关键字，作用是用来计算类型或者变量所占内存空间的大小的，同时也可以用来计算数组所占内存空间的大小和数组中的元素个数。
示例：使用
sizeof()求元素个数
#include <stdio.h>
int main()
{
int arr[10] = {
1,2,3,4,5,6,7,8,9,10}; //这个数组是10个元素，而每个元素占4个字节
printf("%d\n",sizeof(arr)); //sizeof(数组名)计算的是数组所占内存空间的大小，并不是元素的个数/长度。单位是字节，结果是40
printf("%d\n",sizeof(arr[0])); //求1个元素所占内存空间的大小
printf("%d\n",sizeof(arr) / sizeof(arr[0])); //用整个数组所占内存空间的大小除以1个元素所占内存空间的大小，所得出的结果就是这个数组的元素个数
return 0;
}
示例：使用
sizeof()打印每个元素
#include <stdio.h>
int main()
{
int arr[10] = {
1,2,3};
int r = sizeof(arr) / sizeof(arr[0]);
int i = 0;
for (i=0;i<r;i++)
{
printf("%d ",arr[i]);
}
return 0;
}
扩展：在计算一个类型所占内存空间的大小的时候，可以用它的类型，也可以用变量名
#include <stdio.h>
int main()
{
int a = 10;
printf("%d\n",sizeof(a));
printf("%d\n",sizeof a); //在求变量名所占内存空间的大小的时候，可以省略掉()
printf("%d\n",sizeof(int));
return 0;
}
注意：
sizeof()的计算结果是size_t类型的，size_t是无符号的整型类型
size_t类型的打印格式使用%zd占位符来打印的，但如果%zd报错的话，就用%d；主要是看编译器
二：二维数组
数组的元素都是内置类型的，如果把一维数组做为数组的元素，那么这个数组就被称为二维数组；依此类推，如果把二维数组做为数组的元素，那么这个数组就被称为三维数组，三维数组以上的数组统称为多维数组。
1.二维数组的创建
语法格式：
type arr_name[常量值1][常量值2];
- type
：指定的是数组中存放数据的类型，可以是char；short；int；float`等，也可以是自定义类型 arr_name：指的是数组的名字[]：包裹的是常量值，用来指定数组的大小的；在C99标准之前定义数组的大小只能是由常量指定，不能使用变量。- 常量值1：用来指定数组有几行
- 常量值2：用来指定数组有几列
示例：
int arr[3][5];
//int表示数组的每个元素都是整数类型
//arr是数组名
//3表示数组有3行
//5表示数组每一行有5个元素
2.二维数组的初始化
在创建变量或者数组的时候，给定一些初始值，被称为初始化，二维数组也是使用大括号进行初始化的
示例：二维数组的初始化是一行一行放的，当元素把一行放满后，才会进入下一行
#include <stdio.h>
int main()
{
//不完全初始化
int arr1[3][5] = {
1,2};
int arr2[2][6] = {
0};
int arr3[4][8] = {
1,2,3,4,5,6};
//完全初始化
int ar1[3][5] = {
1,1,1,1,1,2,2,2,2,2,3,3,3,3,3};
//按照行来进行初始化
int a1[3][5] = {
{
1,2},{
3,4}{
5,6,7}};
//二维数组在初始化时可以省略行但不能省略列
int arr4[][5] = {
1,2,3}; //这里有1行
int arr5[][4] = {
1,2,3,4,5,6}; //这里有2行
int arr6[][3] = {
{
1,2},{
3,4},{
5,6}}; //这里有3行
return 0;
}
3.二维数组的使用
对二维数组的访问也是使用下标来获取元素的，二维数组是有行和列的，只要锁定了行和列就可以唯一锁定数组中的某一个元素。而C语言规定，二维数组行和列的下标都是从0开始的。
示例：
int arr[3][4] = {
1,2,3,4,5,6,7,8,4,5,6,7};
图解：
示例：访问二维数组中的元素
#include <stdio.h>
int main()
{
//定义一个int类型的二维数组
int arr[3][4] = {
1,2,3,4,5,6,7,8,4,5,6,7};
//通过行和列的下标引用操作符来定位3这个元素
printf("%d\n",arr[0][2]);
return 0;
}
示例：通过下标打印所有元素（二维数组的输出）
#include <stdio.h>
int main()
{
//定义一个int类型的二维数组
int arr[3][4] = {
1,2,3,4,5,6,7,8,4,5,6,7};
//通过下标打印所有元素（数组的输出）
int i = 0;
for(i=0;i<3;i++)
{
int j = 0;
for(j=0;j<4;j++)
{
printf("%d ",arr[i][j]);
}
printf("\n");
}
return 0;
}
示例：给数组输入自己想要的数据（二维数组的输入）
#include <stdio.h>
int main()
{
//定义一个int类型的二维数组
int arr[3][4] = {
1,2,3,4,5,6,7,8,4,5,6,7};
//给数组输入自己想要的数据（二维数组的输入）
int i = 0;
for(i=0;i<3;i++)
{
int j = 0;
for(j=0;j<4;j++)
{
scanf("%d",&arr[i][j]);
}
printf("\n");
}
return 0;
}
4.二维数组在内存中的存储
示例：依次打印二维数组中元素的内存地址
#include <stdio.h>
int main()
{
//定义一个int类型的二维数组
int arr[3][4] = {
1,2,3,4,5,6,7,8,4,5,6,7};
//通过下标打印所有元素（数组的输出）
int i = 0;
for(i=0;i<3;i++)
{
int j = 0;
for(j=0;j<4;j++)
{
printf("&arr[%d][%d] = %p\n",i,j,&arr[i][j]);
}
printf("\n");
}
return 0;
}
从输出结果可以看出，二维数组中每一行内部的每个元素都是相邻的，二维数组随着下标的增长，地址是由低到高变化的，并且每两个相邻的元素之间相差为4（因为1个int整型是4个字节），跨行位置处的两个元素之间也是差4个字节；所以得出一个结论：二维数组在内存中是连续存放的。
5.C99中的变长数组
在C99标准之前，C语言在创建数组的时候，对于数组大小的指定只能使用常量；常量表达式，或者在初始化数据的时候去省略数组的大小，这样的语法创建，让我们在创建数组的时候显得不够灵活，有时候数组大了浪费空间，数组小了又不够用。
示例：
//在C99之前创建数组的方式
int arr1[10]; //使用常量来指定数组的大小
int arr2[7+1]; //使用常量表达式来指定数组的大小
int arr3[] = {
1,2,3}; //初始化数据的时候省略数组的大小
而在C99标准中给出一个变长数组（variable-length array 简称VLA）的新特性，允许我们可以使用变量来指定数组的大小。
示例：
//在C99之后创建数组的方式 -- 变长数组（允许数组的大小是变量的）
#include <stdio.h>
int main()
{
int i = 0;
scanf("%d",&i);
int arr[i]; //变长数组是不能初始化的，会发生报错
return 0;
}
在上面的示例中，arr就是一个变长数组，因为它的长度取决于变量i的值，编译器没办法事先确定，只有在运行时才能知道i是多少。
- 变长数组的根本特征就是数组的长度只有在运行时才能够确定，所以变长数组不能被初始化。
- 变长数组的好处是程序员不必在开发时，随意为数组指定一个估计的长度，程序可以在运行时为数组分配一个精确的长度。
- 变长数组的意思是数组的大小是可以通过变量来指定的，在程序运行的时候，根据变量的大小来指定数组的元素个数，而不是说数组的大小是可变的，数组的大小一旦被确定就不能再变化了
注意：
这个程序此时仍然会发生报错，因为VS虽然支持了C99的语法，但并不是全部支持（变长数组在VS上就是不支持的）（大家可以使用其它的编译器试一下）
6.题目练习
示例1：编写代码，演示多个字符从两端移动，同时向中间汇聚
如：
ABCDEFGHIJK
***********
A*********K
AB*******JK
#include <stdio.h>
#include <string.h>
#include <windows.h> //休眠函数的头文件
int main()
{
char arr1[] = "ABCDEFGHIJK";
char arr2[] = "***********";
int left = 0;
int right = strlen(arr1) - 1;
while(left<=right)
{
arr2[left] = arr1[left];
arr2[right] = arr1[right];
printf("%s\n",arr2);
//添加一个动态的效果，让它运行的时候休眠1秒
Sleep(1000); //休眠函数，单位是毫秒
//在一行上让其向两端移动
system("cls"); //用来执行系统命令的
left++;
right--;
}
//在system()全部清理完成后再打印一次完整的结果
printf("%s\n",arr2);
return 0;
}
示例2：二分查找
二分查找也叫做折半查找，是在一个指定的有序数组中，查找具体的一个数字n，对于这种题目，可以使用遍历和二分查找来做，但遍历数组相比于二分查找，效率比较低
如（1）：用遍历完成
int arr[] = {1,2,3,4,5,6,7,8,9,10};
在arr这个数组中查找到7这个数字；如果找到了就打印下标，找不到就打印找不到
#include <stdio.h>
int main() {
int arr[] = {
1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
int n = sizeof(arr) / sizeof(arr[0]); // 计算数组长度
int target = 0;
scanf("%d", &target);
int found = 0;
for (int i = 0; i < n; i++) {
if (arr[i] == target) {
printf("找到数字%d，下标为%d\n", target, i);
found = 1;
break;
}
}
if (found == 0) {
printf("找不到数字%d\n", target);
}
return 0;
}
如（2）：用二分查找完成
int arr[] = {1,2,3,4,5,6,7,8,9,10};
在arr这个数组中查找到7这个数字；如果找到了就打印下标，找不到就打印找不到
#include <stdio.h>
int main()
{
int arr[] = {
1,2,3,4,5,6,7,8,9,10};
int k = 0;
int s = sizeof(arr)/sizeof(arr[0]);
scanf("%d",&k);
//二分查找
int left = 0;
int right = s - 1;
int find = 0; //假设找不到
while(left<=right)
{
int mid = (left + right) / 2;
if(arr[mid] < k)
{
left = mid + 1;
}
else if(arr[mid] > k)
{
right = mid - 1;
}
else
{
printf("找到了，下标是%d\n",mid);
find = 1;
break;
}
}
if(find == 0)
{
printf("找不到该元素\n");
}
return 0;
}
注意：
当数字过大时超出整型所能表示的最大值（INT_MAX == 2147483647）的时候，内存会溢出，数据会出现错误
扩展：
#include <stdio.h>
int main()
{
int a = 2147483647;
int b = 2147483647;
// int c = (a + b) / 2; //在这种情况下数据会出现错误
int c = a + (b-a) / 2; //这种方法会保证数据正常，不会出现问题
printf("%d\n",c);
return 0;
}
