数组的概念和使用

1. 数组的概念

数组是一组相同类型元素的集合，从这个概念中我们就可以发现2个有价值的信息：

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

 • 数组中存放的多个数据，类型是相同的。 数组分为一维数组和多维数组，多维数组⼀般比较多见的是二维数组。

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

 2.1 数组创建

 ⼀维数组创建的基本语法如下：

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

• type 指定的是数组中存放数据的类型，可以是： char、short、int、float 等，也可以自定义的类型。

• arr_name 指的是数组名的名字，这个名字根据实际情况，起的有意义就行。

 • [ ] 中的常量值是用来指定数组的大小的，这个数组的大小是根据实际的需求指定就行。

int main()
{
    //一维数组的创建
    int math[20];//数组有20个元素，每个元素的类型是int
    char ch[5];
    double arr[6];
    return 0;
}

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

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

2.2 数组的初始化

 有时候，数组在创建的时候，我们需要给定一些初始值，这种就称为初始化。

那数组如何初始化呢？数组的初始化一般使用大括号，将数据放在大括号中。

//完全初始化 
int arr[5] = { 1,2,3,4,5 };
//不完全初始化 
int arr2[6] = { 1 };//第⼀个元素初始化为1，剩余的元素默认初始化为0 
//错误的初始化 - 初始化项太多 
int arr3[3] = { 1, 2, 3, 4 }; 

注：对于字符数组的初始化，也可以使用字符串来初始化

char ch[5] = { 'a','b' };//后面默认为\0,并且不会打印出来
char ch2[5] = "abc";//把a、b、c包括后面的\0放到字符串里去了，\0不会打印出来

当对数组初始化的时候，数组的大小可以省略。编译器会根据数组的初始化内容，自动计算数组的元素个数。

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

那这个数组多少个元素呢？它是根据初始化的内容来确定的，初始化多少个值，它的大小就是多少。 

2.3 数组的类型

 数组也是有类型的，数组算是⼀种自定义类型，去掉数组名留下的就是数组的类型。 如下：

int arr1[10];

int arr2[12];

char ch[5];

arr1数组的类型是 int [10]

arr2数组的类型是 int [12]

ch 数组的类型是 char [5] 

数组名不需要取地址，因为数组名本身就是地址，并不是它没有地址。 

3. 一维数组的使用

 学习了一维数组的基本语法，一维数组可以存放数据，存放数据的目的是对数据的操作，那我们如何使用一维数组呢？

3.1 数组下标  

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

 在C语言中数组的访问提供了一个操作符 [ ] ，这个操作符叫：下标引用操作符。数组的访问是通过下标来访问的。

有了下标引用操作符，我们就可以轻松的访问到数组的元素了，比如我们访问下标为7的元素，我们就可以使用 arr[7] ，想要访问下标是3的元素，就可以使用 arr[3] ,如下代码：

3.2 数组元素的打印

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

3.3 数组的输入

明白了数组的访问，当然我们也根据需求，自己给数组输入想要的数据，如下：

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

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

从输出的结果我们分析，数组随着下标的增长，地址是由小到大变化的，并且我们发现每两个相邻的元素之间相差4（因为一个整型是4个字节）。所以我们得出结论：1.数组在内存中是连续存放的。2.随着数组下标的增长，地址也是从第低（小）到高（大）变化的（地址小的叫低地址，地址大的叫高地址）。这就为后期我们使用指针访问数组奠定了基础（在讲指针的时候我们在再讲，这里暂且记住就行）。&—取地址操作符—取出变量在内存中的地址。这里显示的地址是16进制的。

 x86是32位环境。

 5. sizeof计算数组元素个数

 在遍历数组的时候，我们经常想知道数组的元素个数，那C语言中有办法使用程序计算数组元素个数吗？ 答案是有的，可以使用sizeof。

printf("%d\n", sizeof(a));
printf("%d\n", sizeof(int));

当我们用x86或者x64的环境的时候，打印的结果都为4，但是在x64的环境下会报警告，不过也能打印出来值。

sizeof 中C语言是一个关键字，是可以计算类型或者变量大小的，其实 sizeof 也可以计算数组的大小。 比如：

这里输出的结果是40，计算的是数组所占内存空间的总大小，单位是字节。

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

接下来就能计算出数组的元素个数：

这里的结果是：10，表示数组有10个元素。 以后在代码中需要数组元素个数的地方就不用固定写死了，使用上面的代码计算，不管数组怎么变化，计算出的大小也就随着变化了。

6. 二维数组的创建

6.1 二维数组的概念

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

6.2 二维数组的创建

那我们如何定义二维数组呢？语法如下：

解释：上述代码中出现的信息

• 3表示数组有3行

 • 5表示每一行有5个元素

 • int表示数组的每个元素是整型类型

 • arr是数组名，可以根据自己的需要指定名字

7. 二维数组的初始化

在创建变量或者数组的时候，给定一些初始值，被称为初始化。 那二维数组如何初始化呢？像⼀维数组一样，也是使用大括号初始化的。

7.1 不完全初始化

7.2 完全初始化

7.3 按照行初始化

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

例如;

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

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

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

 8. 二维数组的使用

 8.1 二维数组的下标

当我们掌握了二维数组的创建和初始化，那我们怎么使用二维数组呢？ 其实二维数组访问也是使用下标的形式的，二维数组是有行和列的，只要锁定了行和列就能唯⼀锁定数组中的一个元素。 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。

8.2 二维数组的输入和输出

 访问二维数组的单个元素我们知道了，那如何访问整个二维数组呢？

其实我们只要能够按照⼀定的规律产⽣所有的行和列的数字就行；以上一段代码中的arr数组为例，行的选择范围是0~2，列的取值范围是0~4，所以我们可以借助循环实现生成所有的下标。

int main()
{
    int arr[3][5] = { 1,2,3,4,5, 2,3,4,5,6, 3,4,5,6,7 };
    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. 二维数组在内存中的存储

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

从输出的结果来看，每一行内部的每个元素都是相邻的，地址之间相差4个字节，跨行位置处的两个元素（如：arr[0][4]和arr[1][0]）之间也是差4个字节，所以二维数组在内存中也是连续存放的。

如下图所示：

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

10. C99中的变长数组

 在C99标准之前，C语言在创建数组的时候，数组大小的指定只能使用常量、常量表达式，或者如果我们初始化数据的话，可以省略数组大小。 如：

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

C99中给一个变长数组（variable-length array，简称 VLA）的新特性，允许我们可以使用变量指定数组大小。 请看下面的代码：

上面示例中，数组 arr 就是变长数组，因为它的长度取决于变量 n 的值，编译器没法事先确定，只 有运行时才能知道 n 是多少。

变长数组的根本特征，就是数组长度只有运行时才能确定，所以变长数组不能初始化。它的好处是程序员不必在开发时，随意为数组指定⼀个估计的长度，程序可以在运行时为数组分配精确的长度。

变长数组一旦初始化就会报错。 

有⼀个比较迷惑的点，变长数组的意思是数组的大小是可以使用变量来指定的，在程序运行的时候，根据变量的大小来指定数组的元素个数，而不是说数组的大小是可变的。数组的大小一旦确定就不能再变化了。 遗憾的是在VS2022上，虽然支持大部分C99的语法，没有支持C99中的变长数组，没法测试。DevC＋＋/小熊猫C＋＋底层使用的gcc，gcc支持C99中的变长数组，DevC＋＋和小熊猫C＋＋是同一个祖宗，使用的是gcc，gcc才是编译器，而DevC＋＋和小熊猫C＋＋是一个集成开发环境，他们里面集成的gcc，gcc是支持C99中的变长数组。vscode是一个编辑器，有插件，能支持C/C＋＋环境的搭建，编译器是自己配置的，如果配置gcc就支持。

 小熊猫C＋＋上的变长数组的实现。 

11. 数组练习

 练习1：多个字符从两端移动，向中间汇聚编写代码，演示多个字符从两端移动，向中间汇聚。

#include<stdio.h>
#include<string.h>
int main()
{
    char arr1[] = "welcome to bit...";
    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);
        left += 1;
        right -= 1;
    }
    return 0;
}

下面打印一个动态的效果的代码：

#include <stdio.h>

#include<string.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是一个睡眠函数，S就是大写的，只能在Windows的环境底下用，使用的头文件                    是windows.h。
        arr2[left] = arr1[left];
        arr2[right] = arr1[right];
        left++;
        right--;
        printf("%s\n", arr2);

        Sleep(1000);
    }
    return 0;
}
因为这是个动态的过程，这里就不给大家配图片了。

打印，休眠，这个地方我们可以清理下屏幕，在我们电脑上有一个cmd的命令提示符，这个黑窗口下可以执行很多的命令。

输入dir之后的结果：

 这个上面可以查信息，但我们觉得这个信息很麻烦，想把屏幕清理一下，输入cls就可以清理屏幕：

cls就是我们清理屏幕的一个命令。

但如何执行系统命令呢？用system这个函数就可以了，system函数的头文件是stdlib.h。

system("cls")//清理控制台屏幕的信息 

练习2：二分查找

 在一个升序的数组中查找指定的数字 n ，很容易想到的方法就是遍历数组，但是这种方法效率比较低。

比如我买了⼀双鞋，你好奇问我多少钱，我说不超过300元。你还是好奇，你想知道到底多少，我就让 你猜，你会怎么猜？你会1，2，3，4...这样猜吗？显然很慢；一般你都会猜中间数字，比如：150，然后看大了还是小了，这就是二分查找，也叫折半查找。

折半查找也叫二分查找，二分查找的前提：数据有序的。

int main()
{
    int arr[ ] = { 1,2,3,4,5,6,7,8,9,10 };
    int n = 0;
    scanf("%d", &n);
    int left = 0;
    int sz = sizeof(arr) / sizeof(arr[0]);
    int right = sz - 1;
    int flag = 0;
    while (left <= right)
    {
        int mid = (left + right) / 2;

        if (arr[mid] < n)
        {
            left = mid + 1;
        }
        else if (arr[mid] > n)
        {
            right = mid - 1;
        }
        else
        {
            printf("找到啦，下标为%d\n", mid);
            flag = 1;
            break;
        }
    }
    if (!flag)
    {
        printf("找不到\n");
    }
    return 0;
}

如果没找到的话，只给个flag它的值为0，就不会进入这个if分支语句了，但！flag不为0，刚好进入这个分支语句，打印“没找到”。

但使用left、right求平均值的时候，可能出现潜在的问题，因为一个整型的取值范围有它的最大值也有它的最小值，一个整型占四个字节的空间，一块有限大小的空间里面，放的数字的大小肯定有它的上限。假设给left里面放一个超大的值，给right里面放一个超大的值，但这两个都没有超出最大值，C语言中整型的最大值为4294967295。本来一个变量里面存的数字是有限的，比如一个整型变量里存的值就是这么大，把a和b加起来放到这个整型里面中去，这个地方就存不下了，存不下的时候就有一部分丢了，算出的结果就有问题了。

其实这样就会避免出现这种问题：

查找的步骤：

1.找出中间元素

2.求中间元素的下标，使用 mid = (left+right)/2 ，如果left和right比较大的时候可能存在问题，可以使用下面的方式：

mid = left+(right-left)/2;这种代码就不会出现溢出的情形。