七：《初学C语言》— 数组

• 数组是一组相同类型元素的集合
• 数组中存放的是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;
}