C语言：数组

目录

一、什么是数组

二、一维数组

1.一维数组的创建

2.一维数组的初始化

3.指定初始化器(C99)

4.数组下标

5.数组元素的打印

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

7.sizeof 计算数组元素个数

三、二维数组

1.二维数组的概念

2.二维数组的创建

3.二维数组的初始化

4.二维数组的使用

5.二维数组的输入和输出

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

四、变长数组

五、数组练习

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

2.练习2：二分查找

---

在许多程序中，数组很重要。数组可以作为一种存储多个相关项的便利方式。在今后C语言的学习过程中，我们会和数组打很多交道。接下来我将带着大家解析数组。

本文章只简单介绍数组的相关概念及用法， 在后续讲解指针时将会结合指针来详解数组！

正文开始

---

一、什么是数组

在数学中，我们将各种各样的数集中在一起，这组数就叫集合。同样的，在C中也有能存储一组的数的数据结构，我们称之为数组。数组是按顺序存储的一系列类型相同的值的集合。从这个概念中我们就可以发现2个有价值的信息：

• 数组中存放的是1个或者多个数据，但是数组元素个数不能为0。

• 数组中存放的多个数据，类型是相同的。

数组分为一维数组和多维数组，多维数组一般比较多见的是二维数组。

二、一维数组

1.一维数组的创建

与创建变量类似，数组的创建也是由数据类型和数组名构成，但是数组名后要紧跟着数组元素的个数。一维数组创建的基本语法如下：

type arr_name[常量值];//type为数据类型 arr_name为数组名 方括号中的常量值为元素个数

存放在数组的值被称为数组的元素，数组在创建的时候可以指定数组的大小和数组的元素类型。 

比如：我们现在想存储某个班级的20人的数学成绩，那我们就可以创建一个数组来统计：

int math[20];

当然我们也可以根据需要创建其他类型和大小的数组：

char ch[8];

double score[10];

2.一维数组的初始化

在创建变量时，如果我们没有初始化变量，编译器就会从内存中随机拿取一块空间，将这块空间所表达的值赋给这个变量。所以我们在创建数组的同时，也要根据我们的需要来对数组进行初始化。那数组如何初始化呢？

其实也是一样的道理，我们把数组中的一个个元素看成一个个变量，初始化数组不过就是多初始化几次不同的变量而已。不过数组的初始化一般使用大括号，将数据放在大括号中，每个数据用逗号来隔开。数组的初始化分为完全初始化和不完全初始化：

//完全初始化

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

//不完全初始化

int arr2[6] = {1};//第⼀个元素初始化为1，剩余的元素默认初始化为0

//错误的初始化 - 初始化项太多

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

同时，我们也可以通过和for循环依次赋值来初始化数组：

#include <stdio.h>

int main()
{
    int arr[5] = { 0 };
    int j = 0;
    for (int i = 0; i < 5; i++)
        arr[i] = ++j;
    return 0;
}

或者用scanf()函数和for循环来打组合拳：

#include <stdio.h>

int main()
{
    int arr[5] = { 0 };
    for (int i = 0; i < 5; i++)
        scanf("%d", &arr[i]);
    return 0;
}

3.指定初始化器(C99)

C99增加了一个新特性：指定初始化器。利用该特性可以初始化指定的数组元素。如果我们只初始化最后一个数组元素，在传统C语言中，我们得先初始化最后一个元素之前的所有元素：

① int arr[6] = {0,0,0,0,0,212};

或者先将数组的所有元素初始化为0，然后再为指定元素赋值：

② int arr[6] = { 0 };

    arr[5] = 212;

而②代码就是指定初始化器的原理，它允许我们直接将arr[5] = 212这行代码合并到数组的初始化当中。只需写出指定元素的下标然后并将其赋值，然后其他元素都会自动被初始化为0：

int arr[6] = { [5] = 212};

指定初始化器的特性如下：

①如果指定初始化器后面有更多的值，那么紧跟指定初始化器的后面的值将被用于初始化指定元素后面的元素。比方说上面的代码，我们令[3] = 212，随后在其后面跟上，213 214两个数，那么213 214这两个数将会分别赋给下标为4和下标为5的元素，即[4] = 213，[5] = 214

②如果再次初始化指定的元素，那么最后的初始化将会取代之前的初始化。

③如果未指定数组的大小，那么将会根据指定元素下标的最大值以及指定初始化器后有多少个元素来定义元素个数。

指定初始化器仅仅只是将上方②代码合并在一起，所以平常在编写C程序时还是习惯用②代码的方式，如果知道指定初始化器的用法也可以在C程序中体现，这里只做拓展了解。

4.数组下标

C语言规定数组是有下标的。下标从0开始，假设数组有n个元素，最后⼀个元素的下标是n-1，下 标就相当于数组元素的编号，如下：

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

在C语言中数组的访问提供了一个操作符 [] 。这个操作符叫：下标引用操作符。有了下标访问操作符，我们就可以轻松的访问到数组的元素了。比如我们访问下标为7的元素，我们就可以使用arr[7] ，想要访问下标是3的元素，就可以使用arr[3]，如下代码：

#include <stdio.h>

int main()

{

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

    printf("%d\n", arr[7]);//8

    printf("%d\n", arr[3]);//4

    return 0;

}

输出结果：

5.数组元素的打印

接下来，如果想要访问整个数组的内容，那怎么办呢？只要我们产生数组所有元素的下标就可以了，那我们使用for循环产生0~9的下标，接下来使用下标访问就行了。

#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]);
    }
    return 0;
}

结果：

数组的初始化和打印也可以通过指针实现。在后面学习了指针后，我们也可以通过访问数组元素的地址来初始化数组元素和打印数组元素。

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

有了前面的知识，我们其实使用数组基本没有什么障碍了。如果我们要深入了解数组，我们最好能了解一下数组在内存中的存储。我们来依次打印数组元素的地址：

#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("&arr[%d] = %p\n ", i, &arr[i]);
    }
    return 0;
}

输出结果：

从输出的结果我们分析，数组随着下标的增长，地址是由小到大变化的，并且我们发现每两个相邻的元素之间相差4(因为一个整型是4个字节)。所以我们得出结论：数组在内存中是连续存放的。这就为后期我们使用指针访问数组奠定了基础。

7.sizeof 计算数组元素个数

在遍历数组的时候，我们经常想知道数组的元素个数，这时我们可以通过sizeof来计算数组的元素个数：

#include <stdio.h>

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

结果：

这里输出的结果表示的是数组所占内存空间的大小，单位是字节。因为数组元素的数据类型是int，而int所占空间为4个字节，这里有10个int类型的元素，所以大小总共为40字节。

我们又知道数组中所有元素的类型都是相同的，那只要计算出一个元素所占字节的个数，数组的元素个数就能算出来。这里我们选择第一个元素就可以。 

#include <stdio.h>

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

结果：

三、二维数组

1.二维数组的概念

前面学习的数组被称为一维数组，数组的元素都是内置类型的，如果我们把一维数组做为数组的元 素，这时候就是二维数组。二维数组作为数组元素的数组被称为三维数组，二维数组以上的数组统称为多维数组。

2.二维数组的创建

type arr_name[常量值1][常量值2]；

例如：

int arr[3][5];

double data[2][8];

与一维数组的创建类似，二维数组比一维数组仅多了一个列。例如上述代码中的int arr[3][5]，它解读为数组的类型为int类型，名字为arr，有3行，5列。所以常量值1代表行数，常量值2代表列数。

3.二维数组的初始化

二维数组也是数组，因此它的初始化也分为完全初始化和不完全初始化：

//不完全初始化

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

int arr2[3][5] = {0};

//完全初始化

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

同时也可以这样初始化：

//行初始化

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

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

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

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

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

如果是不完全初始化，编译器会自动地将括号中的元素从左到右从上到下依次填满整个数组。如果是行初始化，编译器将按照括号内的子括号依次填至数组的每行，从每行的首元素开始。如果省略行进行初始化，编译器将根据括号内的元素个数和列数来决定行数。

4.二维数组的使用

当我们掌握了二维数组的创建和初始化，那我们怎么使用二维数组呢？其实二维数组访问也是使用下标的形式的，二维数组是有行和列的，只要锁定了行和列就能唯一锁定数组中的一个元素。C语言规定，二维数组的行是从0开始的，列也是从0开始的，如下所示：

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

图中最右侧绿色的数字表示行号，第一行蓝色的数字表示列号，都是从0开始的。比如，我们说：第2行第4列，快速就能定位出7。

#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][4]);
    return 0;
}

5.二维数组的输入和输出

访问二维数组的单个元素我们知道了，那如何访问整个二维数组呢？其实我们只要能够按照一定的规律产生所有的行和列的数字就行。以上一段代码中的arr数组为例，行的选择范围是0~2，列的取值范围是0~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};
    for(int i=0; i<3; i++)//产生行号
    {
        for(int j=0; j<5; j++)//产生列号
            printf("%d ", arr[i][j]);//输出数据
        printf("\n");
    }
    return 0;
}

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

像一维数组一样，我们如果想研究二维数组在内存中的存储方式，我们也是可以打印出数组所有元素的地址的：

#include <stdio.h>

int main()
{
    int arr[3][5] = { 0 };
    int i = 0;
    int j = 0;
    for (i = 0; i < 3; i++)
    {
        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])之间也是差4个字节，所以二维数组中的每个元素都是连续存放的。

了解清楚二维数组在内存中的布局，有利于我们后期使用指针来访问数组的学习。

四、变长数组

在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中的变长数组，没法测试；下面是我在gcc编译器上测试，可以看⼀下。

#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;
}

第一次测试，我给n中输入5，然后输入5个数字在数组中，并正常输出

第一次测试，我给n中输入5，然后输入5个数字在数组中，并正常输出

接下来我们来做两个练习：

五、数组练习

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

---

在讲解此题前先介绍几个概念。

第一个概念是字符数组。字符数组是由若干个数组元素组成的，它可用来存放整个字符串(即用字符数组来存放字符串)。例如：

char arr1[] = "welcome to bit...";

char arr2[] = "#################";

实际上在字符数组的末尾还有一个'\0'，这是编译器为我们加上的。所以arr1和arr2从表面上看是17个字符的空间，但实际上还有隐藏起来的末尾0，总共是18个字符的空间。

同时我们也可将arr1和arr2中的字符串分别拆开，拆成由一个个字符组成的数组，两种写法是等价的。但是注意如果要用一个个字符来表示一个字符数组的话，一定要在最后加上一个'\0'，否则就无法求得这个数组的长度，因为编译器不能为这种数组自动添上'\0'，它也不知道何时遇到'\0'，所以最后会输出一个随机数。

第二个概念是strlen()函数。它定义在<string.h>头文件中。它用于计算以空字符('\0')结尾的字符串的长度，但不包括结尾的空字符本身。比如上述两个字符数组，我们就可以通过strlen()函数来计算它们的长度：

#include <stdio.h>

int main()
{
	char arr1[] = "welcome to bit...";
	char arr2[] = "#################";
	int len1 = strlen(arr1);
	int len2 = strlen(arr2);
	printf("%d %d", len1, len2);
	return 0;
}

了解以上概念后，我们来逐步解析练习1。

---

首先我们定义一个数组arr1，将其内容设置为我们要移动的字符；再定义一个arr2，将其内容设置为若干个井号，便于我们在输出结果观察字符的移动过程。这里数组arr1和arr2内容自定义：

#include <stdio.h>

int main()
{
	char arr1[] = "welcome to bit...";
	char arr2[] = "#################";
	return 0;
}

然后，由于题目是让我们将字符从两端移动向中间汇聚，那么我们就要取数组arr1的两端！该怎么取呢？数组arr1的左端是很好取的，就是它的首元素，我们不妨定义一个int类型的变量left。数组的元素是由下标表示的，那么我们将left初始化为0。其次是右端，我们都知道数组最后一个元素的下标在数值上的关系是与数组长度相差1的，那么我们不妨先取数组arr1的长度。由于是字符数组，所以我们用strlen()函数求它的长度，然后再-1，得到的就是数组arr1最右端也就是最后一个元素的下标。同样的，我们定义一个int类型的变量right，将其初始化为strlen(arr1)-1：

​#include <stdio.h>

int main()
{
	char arr1[] = "welcome to bit...";
	char arr2[] = "#################";
	int left = 0;
	int right = strlen(arr1) - 1;
	return 0;
}

由于我们要观察移动的过程，我们先将arr2数组打印出来：

​#include <stdio.h>

int main()
{
	char arr1[] = "welcome to bit...";
	char arr2[] = "#################";
	int left = 0;
	int right = strlen(arr1) - 1;
	printf("%s\n", arr2);
	return 0;
}

看题目要求，多个字符从两端开始移动，说明是循环，这里为了方便我们就用while循环。最后左端和右端会在中间相聚，所以while表达式的语句应为left<=right。如果left>right或者righet>left，就会造成输出结果的错误！

​#include <stdio.h>

int main()
{
	char arr1[] = "welcome to bit...";
	char arr2[] = "#################";
	int left = 0;
	int right = strlen(arr1) - 1;
	printf("%s\n", arr2);
    while (left <= right)
    {
    }
	return 0;
}

为了便于观察，我们在while循环中加入Sleep()函数，它用于使程序暂停执行指定的毫秒数。这里我们就输入1000让while每一秒输出一个结果，让移动过程更加明显易懂。然后我们让arr2中的元素等于arr1对应位置的元素，左端等于左端，右端等于右端。让左端向中间移动，就是left++，而让右端向中间移动，就是right--，然后打印输出结果：

#include <stdio.h>

int main()
{
	char arr1[] = "welcome to bit...";
	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.练习2：二分查找

在⼀个升序的数组中查找指定的数字n，很容易想到的方法就是遍历数组，但是这种方法效率比较低。比如我买了一双鞋，你好奇问我多少钱，我说不超过300元。你还是好奇，你想知道到底多少，我就让你猜，你会怎么猜？你会1，2，3，4...这样猜吗？显然不是；一般你都会猜中间数字，比如：150，然后看大了还是小了。这就是二分查找，也叫折半查找。

同样的道理，我们先给出一个整型数组，然后将它的两端定义出来：

#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;
    return 0;
} 

我们找一个我们想要找到的数字，定义变量key储存这个数字。由于是二分查找，我们再定义一个变量叫mid，用来存储中间元素的下标。然后再定义一个变量用来表示我们是否找到，我们将它命名为find吧：

#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;
    return 0;
} 

二分查找实际上也就是不断缩小左端下标和右端下标之间的范围大小，所以和练习1一样，循环查找时右端下标不能大于左端下标。然后我们将记录中间元素下标的变量mid赋值。每次查找时右端和左端会不断向中间靠拢，所以mid的值会随之改变：

#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;
    }
    return 0;
} 

运用二分查找时，我们会尽量让被查找元素处在绝对中间，也就是这个被查找元素两边元素的数量相同。

比如1 2 3 4 5 6 7，我们要查找5，我们就要让5尽量处在中间的位置。但是5的位置现在处于中间偏右，为便于理解，我们不妨将5视为中间元素(但实际上不是中间元素，中间元素时其他的元素，我们在这里只是作为一个参考系)，可以发现5的左边有4个元素，而右边只有两个元素，为了让5处于绝对中间位置(也就是让数组中间下标恰好等于5的下标，这也就是为什么让mid = left /2 + right /2这行代码处在while循环当中，因为缩小查找范围的同时，下标为中间元素下标的元素在不断改变)，我们要让左端的元素变少，实际上就是缩小我们的查找范围。我们不妨先把1拿出去，就变成：2 3 4 5 6 7。同时5的下标也随之改变。这时还是左边元素多，那就再拿出去一个：3 4 5 6 7。这时5的下标正好等于数组中间元素的下标，这时我们就找到了。因此：

#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;
        }
    }
    return 0;
} 

在前面我们定义了一个变量find用于判断我们是否找到了我们要查找的元素。如果找到了我们就令它等于1：

#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;
        }
    }
    return 0;
} 

这样设置的同时也排除了一些特殊情况，也便于程序的执行：

#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;
} 

这便是二分查找的C程序代码。

---

以上就是本章数组的全部内容~有不足的地方还请大佬指点~