C语言：数组

数组

数组的概念

引例

如果我们要在程序中表示一个学生的成绩，我们会使用一个int来表示，如：int score。假如我们要在程序中表示一组成绩，此时我们所学的常规的数据类型就无法再表示，这个时候我们就需要使用一种新的表现形式，这种表现形式就是我们的数组。

什么是数组

数组是相同类型，有序数据的集合。

数组的特征

• 数组中的数据被称为数组的元素，是同构的
• 数组中的元素放在内存空间里（如：char ct_name[20]：再内存中申请6块连续的基于char类型的变量空间）

衍生概念：下标（索引）

• 下标或索引代表了数组中元素距离第一个元素的偏移位置
• 数组中的元素的地址值，下标越大，地址值越大（每一块内存空间都有一个独有的内存地址，变量空间以字节为单位进行地址的标注，我们也可以说1内存单元=1字节）
• 数组的下标是从0开始

一堆数组

数组的定义

语法：

类型说明符 数组名[数组容量]

说明：

• 数组的类型说明符由数组中的元素来决定，也就是元素是什么类型，数组就是什么类型。
• 数组名也是标识符，我们所说的数组[名]，大家可以理解为数据类型是数组的变量(名)。命名规则与变量名相同。遵循标识符命名规则。
• 数组容量也可以叫做元素个数或者常量表达式，表达式必须为整型，可以包含常量和符号常量，但不能是变量。

int arr[5];// 常量


#define COUNT 5
int arrp[COUNT];// 符号常量


int arr[800 * 480];// 常量表达式

类型：代表了数组中元素的类型。

容量：数组中能存储多少个元素，数组容量可以是常量、常量表达式、符号常量，但必须是整数。

深入理解：

• 定义一个数组，相当于申请了一个可以容纳所指定元素数量的内存空间。所申请的内存单元是连续的。
• 定义一个数组，相当于定义了多个匿名的变量，这些变量可以通过数组名[下标]来标识。

举例：

// 定义一个数组
int arr[10];// 问题：这个数组中，最小索引：0，最大索引：9 = 数组元素个数 - 1

经过上面的案例，分析得到：

数组的最大下标 = 数组元素个数（数组容量） - 1

数组元素的访问

原则：数组中的元素不能一次性访问所有元素，只能一个一个的访问。

语法：

数组名[下标]

说明：以上语法，既能实现数组中元素的取，也能够实现数组中元素的存。

举例：

// 定义一个能够容纳10个元素的int数组
int arr[10];
// 给数组的第一个元素进行赋值
arr[0] = 89;
arr[0] = 88;// 覆盖上面的赋值

// 访问数组的第一个元素
int a = arr[0];// 88

// 问题：以下访问是否正确
int b = arr[10];// error：下标越界异常

注意：数组元素的访问一定不能越界。

案例：

#include <stdio.h>

/**
 * 需求：一位数组案例-引用数组元素。利用循环给数组元素赋值0~9，并且逆序输出。
 */
int arr_test1()
{
    // 创建一个数组
    int arr[10];
    
    // 利用for循环给数组元素赋值
    for(int i = 0;i < 10;i++)
    {
        arr[i] = i + 10;
    }
    // 逆序输出
    // 通过一个循环将数组中的每一个元素取出，称之为遍历。
    for(int j = 9;j >= 0;j--)
    {
        printf("%-5d/t",arr[j]);
    }
}

int main(int argc,char *argv)
{
    arr_test1();
    return 0;
}

数组的初始化

数组初始化：定义数组的同时，用指定数据来给对应元素赋值。

简化数组定义后，需要对元素一一赋值操作。

语法：

类型 数组名[容量大小] = {常量1，常量2，常量3...}；

注意：

• 数组可以部分初始化：也就是可以给数组中的前几个元素初始化，未被初始化的元素系统将会自动初始化；如果定义数组时未被指定数据容量，则系统会根据初始化元素的个数来决定数组容量。

// 1.如果定义数组时只给数组前几个元素初始化，后续剩余元素会自动完成初始化
int arr[10] = {11,12,13,14,15};// 推荐写法,等价于以下写法
int arr[10] = {11,12,13,14,15,0,0,0,0,0};

// 2.如果定义数组时，未指定数组容量，根据初始化的元素的个数来决定容量
int arr[] = {1,2,3,4,5};// 推荐写法，等价于以下写法
int arr[5] = {1,2,3,4,5};

衍生概念：

• ==柔性数组：==柔性数组的概念在C99标准，针对结构体的最后一个成员可以是一个未指定大小的数组；
  • 广义简单理解：数组容量待定，或者确定的数组，举例：int arr[] = {1,2,3,4,5}

面试题：

• 在不知道数组类型的情况下，如何确定数组元素的个数

int length = sizeof(arr) / sizeof(arr[0]);

说明：

1. arr就是我们计算的数组本身，sizeof(arr)用来计算该数组中总的字节大小。
2. sizeof(arr[0])用来计算数组中第一个元素所占的字节大小，因为数组中元素类型相同，所以计算哪一个都可以。
3. sizeof(arr)/sizeof(arr[0])就是用数组中总的字节数除以每一个元素所占的字节数，从而得到元素的个数。

一维数组案例：

案例1：

#include <stdio.h>

/**
 * 需求：一维数组案例-非波拉契数列
 */
int arr_test1()
{
    int f[20] = {1,1};// 定义一个数组，用来存储数列，默认存储第1位和第2位
    
    // 计算获取数组的大小，主要用于遍历数组
    int length = sizeof(f) / sizeof(f[0]);
    
    // 将生成的序列存入数组(索引绕过0和1)
    for(int i = 0;i < length;i++)
    {
        // 给数组元素赋值，从数组的第3个元素开始
        f[i] = f[i-1]+f[i-2];
        // 遍历数组
        for(int j = 0;j < length;j++)
        {
            // 遍历的时候，要求一行显示5个数
            if(j % 5 == 0)
            {
                printf("\n");
            }
            printf("%-6d",f[j]);
        }
        printf("\n");
    }
    
}

int main(int argc,char *argv)
{
    arr_test2();
    return 0;
}

案例2：

/**
 * 需求：一维数组案例-非波拉契数列
 */
int arr_test2()
{
  int f[20] = {1, 1}; // 定义一个数组，用来存储数列，默认存储第1位和第2位

  // 计算获取数组的大小，主要用于遍历数组
  int len = sizeof(f) / sizeof(f[0]);

  // 将生成的序列存入数组(索引绕过0和1)
  for (int i = 2; i < len; i++)
  {
    // 给数组元素赋值，从数组的第3个元素开始
    f[i] = f[i - 1] + f[i - 2];
  }
    // 遍历数组
    for (int j = 0; j < len; j++)
    {
      // 遍历的时候，要求一行显示5个数
      if (j % 5 == 0)
      {
        printf("\n");
      }
      printf("%-6d", f[j]);
    }
  printf("\n");
}

int main(int argc,char *argv)
{
    arr_test2();
    return 0;
}

案例3：

/**
 * 需求：一维数组案例-冒泡排序
 */
int arr_test3()
{
  // 创建一个数组，用来存储排序的序列
  int arr[10];
  // i:外层-比较的轮数，j：内层-每一轮比较的次数，temp：临时变量，用来比较时交换数据交换
  int i,j,temp;

  printf("请输入10个测试整数：\n");

  // 计算数组的大小
  int len = sizeof(arr) / sizeof(arr[0]);

  // 循环录入数据
  for(i = 0;i < len;i++)
  {
    scanf("%d",&arr[i]);
  }
  printf("\n");

  // 对数组arr使用冒泡进行排序（注意：我们使用的标准的冒泡排序，可以继续优化）

  // 外层循环：控制比较的轮数，轮数 = 数组容量 - 1，这个案例比9轮
  for(i = 0;i < len - 1;i++)
  {
    // 内层循环：每一轮比较的次数，每一轮比较的次数：
    for(j = 0;j < len - 1 - i;j++)
    {
      // 相邻的两个数比较，满足条件就交换位置
      if (arr[j] > arr[j+1])
      {
        temp = arr[j];
        arr[j] = arr[j+1];
        arr[j+1] = temp;
      }
    }
  }
  printf("冒泡排序遍历数组：\n");

  for (i = 0; i < len; i++)
  {
    printf("%-4d",arr[i]);
  }
  printf("\n");
}
int main(int argc,char *argv)
{
    arr_test3();
    return 0;
}

案例4：

/**
 * 需求：从键盘输入年、月、日，并计算输出是该年的第几天，2024-12-3
 */
int arr_test4()
{
  // 定义变量：年、月、日，统计天数，循环变量：用来遍历当前月前面的月份
  int year,month,day,sum,k;
  // 定义一个数组，用来存放1~12月每月的天数
  int t[] = {31,28,31,30,31,30,31,31,30,31,30,31};// 柔性数组

  printf("请输入年份、月份、天：（使用-分割）\n");
  scanf("%d-%d-%d",&year,&month,&day);// 2024-12-3

  // 因为2月比较特殊，存在平年和闰年的因素，所以要进行判断处理
  if ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0))
  {
    t[1] = 29;// 闰年
  }

  // 先将输入的天记录到总天数
  sum = day;

  // 计算当前月前的所有月的天数
  for(k = 0;k < month - 1;k++)
  {
    sum += t[k];
  }

  printf("%d月%d日是%d年的第%d天。\n",month,day,year,sum);

}


int main(int argc, char *argv)
{

  arr_test4();
  return 0;
}