C语言-一维数组，二维数组

数组

数组的引入

• 如果要在程序中保存一个人的年龄？如何保存？

  答：创建一个基于int类型的变量，举例：int age = 22

• 如果要在程序中保存一个人的三门课的成绩？如何保存？

  答：创建三个基于float类型的变量，举例：float score1 score2 score3；

  • 保存一个人15门课程的成绩？如何保存？ -----数组

数组的概念

什么是数组

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

数组的特征

• 数组中的数据被称为数组的元素（所谓的元素，其实就是数组的每一个匿名的变量空间),是同构。
• 数组中的元素存放在内存空间（char player_name[6]: 申请在内存中开辟6块连续的基于char类型的变量）

衍生概念：下标（索引）

• 下标（索引）代表了数组中元素距离第一个元素（首地址所在的元素）的偏移量。 举例：第一个元素距离第一个元素的偏移量是0，所以数组中的下标是从0开始的。

• 数组的下标是从0开始的：

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

int a：在内存中开辟1块空间，该空间的大小是4个字节。

int a1,a2,a3,a4,a5：在内存中开辟连续的5块空间，每一块空间的大小是4个字节。但是不如数组方便。

int arr[5]：在内存中开辟连续的5块空间，每一块空间的大小是4个字节。

一维数组

数组的定义

语法：

数据类型 数组名[数组容量];

注意：数据类型又被称作类型说明符，数组容量又被称作数组元素个数或者数组的大小/长度。

说明：

• 数组的数据类型由数组中的元素来决定。也就是说数据类型，由元素的类型来决定，元素是什么类型，数组就是什么类型。同一个数组中，所有元素的类型都是一致的。

• 数组名也是标识符，我们所说的数组（名），大家可以理解为数据类型是数组的变量（名）。命名规则与变量的规则一样，唯一的区别是变量使用单数，数组使用复数。也就是以字母或者下划线开头，后面只能跟字母、数字、下划线。

• 数组容量还可以叫做常量表达式。**其值必须是整数。**关于数组容量的类型：

  • C89标准：只支持常量和符号常量，不支持变量。

    #define SIZE 5   // 符号常量，使用宏定义int lenght = 5;  // 变量int arr1[5];     // 常量（字面量）正确
    int arr2[SIZE];  // 符号常量，正确
    int arr3[length];// 变量，C89错误
    

  • C99标准（大部分环境支持）：引入==变长数组（VLA）==的概念，就是可以使用变量，数组在运行的时候决定大小。举例：

    int length = 5;  // length = 5; 创建一个变量length，赋值5
    int arr[length]; // 创建一个容量为5的数组，C99标准下是正确的（执行这句的代码的时候，已经在内存申请空间）
    length = 10;     // 此时虽然变量length的值变成了10，但是已经创建的数组的大小是不会改变的。数组大小依然是5

类型：

​ 代表了数组中元素的类型，数组的空间大小 = 数组中所有元素空间之和。

容量：

​ 数组中能存储多少个元素，数组容量一定是一个整型。

深入理解：

​ ① 定义一个数组，相当于申请了一个可以容纳所指定元素个数的内存单元。所申请的内存单元是连续的。

​ ② 定义一个数组，相当于定义了多个匿名的变量，这些变量可以通过数组名[下标]来访问。

范例：

// 定义一个数组
int arr[10]; // 定义一个存放10个int类型元素的数组

关于数组中元素默认值问题：

• **全局作用域和static修饰的变量：**元素的默认值是0

• 局部作用域：元素的默认值是随机值，此时强烈建议用户初始化。

  举例：

  #include <stdio.h>int g_age;    // 全局作用域，定义在函数的外面，默认值是0
  int g_ages[5];// 全局作用域，等同于全局变量，元素的默认值是0int main(int argc, char *argv[])
  {int p_age;   // 局部作用域：函数中定义的所有的变量都属于局部作用域。变量使用前需要初始化。int p_ages[5]; // 局部作用域：元素的值使用前需要初始化return 0;
  }
  

  **注意：关于默认值 ，整型和浮点型的默认值是0，字符型的默认值是\0，\0**对应的ASCII码为0

数组元素的访问

原则：

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

语法：

• 取值：

  数组名[下标];
  

• 赋值：

  数组名[下标] = 值;
  

举例：

// 定义一个存储10个元素的int数组
int arr[10];// 给数组的第一个元素进行赋值
arr[0] = 88;// 访问数组的第一个元素
int a = arr[0];// 修改数组中第一个元素的值
arr[0] = 66; // 使用66覆盖88int c = arr[9]; // 如果是一个局部作用域的数组，此时访问的元素的值是 随机值；如果是全局作用域，值是0
int b = arr[10];// error，报一个错误：下标越界异常，因为访问了一个未知的存储空间

案例

• 需求：利用循环给数组元素a[0]~a[9]赋值0~9，并且要求逆序输出。

• 代码：

  #include <stdio.h>int main(int argc,char *argv[])
  { // 创建一个数组，用来存放0～9int arr[10];// 计算数组的大小：数组大小 = 数组所有元素的总字节数 / 每一个元素的字节数 需要使用到sizeof运算符int len = sizeof(arr) / sizeof(arr[0]);// 通过for循环给数组赋予0～9for (int i = 0; i <= 9; i++) arr[i] = i;// 逆序输出数组中的元素：数组最大下标 = 数组大小 - 1// 使用for循环获取数组每一个元素称之为数组的遍历for (int j = len -1; j >= 0; j--) printf("%4d", arr[j]);printf("\n");return 0;
  }

  结果：

数组的初始化

说明：所谓的初始化，就是定义数组的时候，用指定的数据给对应的元素赋值。

语法：

数据类型 数据组[数组容量] = {...};

注意事项：

• 数组可以部分初始化：也就是可以给数组中的前几个元素初始化，未被初始化的元素系统将自动初始化，初始值是0。（也就是一个数组织中，一旦有元素被初始化，剩余的元素将自动初始化为0）

// 数组的部分初始化
int arr[10] = {11,12,13,14,15};  // 推荐写法：只初始化前5个元素，剩余元素系统默认为0，等价于下面写法
int arr[10] = {11,12,13,14,15,0,0,0,0,0};char arr1[5] = {'a','b','c'}; // 推荐写法，等价于下面写法
char arr1[5] = {'a','b','c','\0','\0'}; // 等价于下面写法
char arr1[5] = {'a','b','c',0,0}; // '\0' 对应的ASCII码是 0   char a = 'A' 等价于 char a = 65int arr2[5] = {}; // 等价于下面第三种写法
int arr2[5] = {0};// 等价于下面第三种写法，推荐
int arr2[5] = {0,0,0,0,0};

• 数组根据初始化的元素自动分配大小：如果定义数组时未指定数组容量，则系统会根据初始化的元素的个数来决定容量。

  // 由初始化的元素来决定数组的容量
  int arr[] = {11,12,13,14,15}; // 推荐写法，等价于下面写法
  int arr[5] ={11,12,13,14,15}; 
  

案例

案例1

• 需求：求斐波拉契数列，限制在20个。

• 分析：1,1,2,3,5,8…

• 代码：

  #include <stdio.h>int main(int argc,char *argv[])
  {//定义循环变量int i;//定义一个数组，用来存储20个数列int f[20] = {1,1};//计算数组的大小int len = sizeof(f) / sizeof(f[0]);//通过一个for循环完成数列for( i = 2; i < len; i++) f[i] = f[i-1] + f[i-2];//{1,2,3,4}//遍历数组for(i = 0; i < len;i++){//一行显示5个数if (i > 0 && i % 5 == 0) printf("\n");printf("%8d",f[i]);}printf("\n");return 0;
  }

  结果：

  

案例2

• 需求：从键盘输入年、月、日，计算并输出该日是该年第几天。

• 分析：

  • 首先创建一个数组，用来存放每一个月的天数，因为二月特殊，初始化的时候，默认为平年天数。
  • 从控制台输入年，月，日
  • 闰年校验：如果是闰年，就修改数组中二月份对应的天数（平年：28天，闰年：29天）。
  • 定义一个变量，用来记录天数，默认就是我们输入的天数。
  • 遍历数组，将输入月份之前的每一个月的天数取出来加到记录天数的变量中。
  • 将统计后的天数打印输出。

• 代码：

  #include <stdio.h>int main(int argc,char *argv[])
  {// 首先创建一个数组，用来存放每一个月的天数，因为二月特殊，初始化的时候，默认为平年天数。int t[] = {31,28,31,30,31,30,31,31,30,31,30,31};// 从控制台输入年，月，日int year,month,day;printf("请输入年份、月份、天（yyyy-MM-dd）:");scanf("%d-%d-%d", &year, &month, &day);// 闰年校验：如果是闰年，就修改数组中二月份对应的天数（平年：28天，闰年：29天）。if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) t[1] = 29;// 定义一个变量，用来记录天数，默认就是我们输入的天数。int sum = day;// 遍历数组，将输入月份之前的每一个月的天数取出来加到记录天数的变量中。for (int i = 0; i < month - 1; i++) sum += t[i];// 将统计后的天数打印输出。printf("%d月%d日是%d年的第%d天！\n", month, day, year, sum);return 0;
  }

  结果：
  

二维数组

定义

二维数组本质上是一个行列式组合，也就是说二维数组是由行和列两部分组成，属于多维数组。二维数组通过行和列解读（先行后列）

二维数组可被视为一个特殊的一维数组，也就是说，当一个数组中的每一个元素是一位数组的时候，那么这个数组就是二维数组。

语法

数据类型 数组名[行容量][列容量];  

行容量：外层数组的数组容量

列容量：内存数组的数组容量

说明

• 二维数组在初始化的时候，可以省略行数，系统会通过初始化后的数据自动推断行数。
• 二维数组和一位数组一样，也可以部分初始化，未初始化的元素使用0。
• 二维数组在初始化的时候，不能省略列数，否则编译报错。

举例

int arr[3][3] = {{11,12,13},{21,22,23},{31,32,33}};   // 正确，等价于下面写法
int arr[][3]  = {{11,12,13},{21,22,23},{31,32,33}};   // 正确，二维数组初始化的时候可以省略行容量，推荐int arr[3][3] = {{11,12},{21,22,23},{31}};            // 正确，可以未初始化部分补0，等价于下面写法
int arr[3][3] = {{11,12,0},{21,22,23},{31,0,0}};      // 正确，支持部分初始化int arr[3][3] = {0};                                  // 正确，所有位置使用0补齐，推荐
int arr[3][3] = {};                                   // 正确，所有位置使用0补齐
int arr[3][3] = {11};                                 // 正确，除了0行0列是11外，其他都用0补齐int arr[][] = {{11,12,13},{21,22,23},{31,32,33}};     // 错误，编译报错，不能省略列容量
int arr[3][] = {{11,12,13},{21,22,23},{31,32,33}};    // 错误，编译报错，不能省略列容量int arr[][3]  = {11,12,13,21,22,23,31,32,33};         // 正确，{}中不一定要嵌套
int arr[][3]  = {11,12,13,21};                        // 正确，{}中不一定要嵌套

注意：在C语言中，二维数组在计算机的存储顺序是按行进行的，即第一维（行）下标变化慢，第二维的（列）下标变化快。

内存存储

注意：地址这里只是为了区分，实际的地址表示为十六进制。

应用场合

主要是应用对行列有要求的情况。比如说我们现在要存储西安粤嵌所有在班学生的成绩。

还有就是字符数组的应用，比如用数组存储学生的姓名。

double scores[35] = {..}; 一维数组初始化，存放1个班所有学生的成绩

double scores[5][40] = {{..}..} 二维数组初始化，存放5个班的学生成绩，每个班最多40人。

double scores[6][10][40] = {{{..}..}..} 三维数组初始化，存放6个校区、每校区最多10各班，每班最多40人。

特殊写法

• 下标可以是整型表达式。如：a[2-1][2*2-1] → a[1][3]

• 下标可以是已经有值的变量或者数组元素。如：a[2*x-1][b[3][1]] []中最终需要的是一个>0的整数。

• 数组元素可以出现在表达式中。如：b[1][2] = a[2][3]/2

• 演示：

  数组：arr	列-0	列-1	列-2	举例	说明
  行-0	11	12	13	arr[0][1]	数组arr的0行1列对应的元素
  行-1	21	22	23	arr[1][2]	数组arr的1行2列对应的元素

注意：使用数组元素的下标应在已定义数组的大小范围内；应注意区别定义数组大小和引用数组元素的区别。

初始化

• 分行给二维数组赋初值

  int arr[3][4] = {{11,12,13,14},{21,22,23,24},{31,32,33,34}};
  

• 可将所有数据写在一个{}内，按照排列顺序对运算赋值

  int arr[3][4] = {11,12,13,14,21,22,23,24,31,32,33,34};
  

• 可对部分元素赋初值，其余未初始化部分自动填充0

  int arr[3][4] = {{11},{21,22},{31,32,33}};
  

• 若对全部元素赋初值，自定义数组时可以省略第一维数组容量（行容量），第二维数组容量（列容量）必须指明。

  int arr[][4] = {{11,12,13,14},{21,22,23,24},{31,32,33,34}};
  int arr[][4] = {11,12,13,14,21,22,23,24,31,32,33,34};
  

• 在分行赋初值时，也可以省略第1维的长度(行容量)。

  int arr[][4] = {{11,12,13},{0},{0,10}};
  

案例

案例1

• 需求：二维数组的遍历

• 分析：

  • 二维数组本质上属于行列式，遍历的时候需要借助于嵌套的for循环，外层for负责行的遍历，内层for负责列的遍历。

  • 取值：

    数组名[行容量][列容量];
    

  • 赋值：

    数组名[行下标][列下标] = 值;
    

  • 行和列的大小计算：

    // 计算行的大小
    int row_length = sizeof(数组名) / sizeof(数组名[行下标0]);
    // 计算列的大小（每一行的列数是相同）
    int col_length = sizeof(数组名[行下标0]) / sizeof(数组名[行下标0][列下标0]);
    

• 代码：

  #include <stdio.h>int main(int argc,char *argv[])
  {// 创建一个二维数组int arr[][3] = {{11},{21,22},{31,32,33}};// 获取行和列的大小int row_len = sizeof(arr) / sizeof(arr[0]);// 外层数组大小int col_len = sizeof(arr[0]) / sizeof(arr[0][0]);// 内层数组大小，因为每个内层数组大小一致，所以计算第一个就可以了// 遍历数组// 外层循环：遍历行for (int i = 0; i < row_len; i++){// 内层循环：遍历列for (int j = 0; j < col_len; j++){// 输出元素printf("%-4d", arr[i][j]);}}printf("\n");return 0;
  }

• 运行结果：

  

案例2

• 需求：矩阵的转置

• 分析：

  • 所谓的转置，就是原本的列变行，行变列。

    

• 代码：

  #include <stdio.h>#define ROW 2
  #define COL 3int main(int argc,char *argv[])
  {// 定义循环变量int i,j;// 准备2个数组，用来存放转置前后的数列int arr_before[ROW][COL] = {11,12,13,21,22,23};int arr_after[COL][ROW] = {0};// 计算数组的大小int arr_before_row = sizeof(arr_before) / sizeof(arr_before[0]);int arr_before_col = sizeof(arr_before[0]) / sizeof(arr_before[0][0]);int arr_after_row = sizeof(arr_after) / sizeof(arr_after[0]);int arr_after_col = sizeof(arr_after[0]) / sizeof(arr_after[0][0]);// 循环遍历二维数组printf("\n转置前：\n");for (i = 0; i < arr_before_row; i++){for (j = 0; j < arr_before_col; j++){// 打印转置前的数据printf("%-4d",arr_before[i][j]);// 转置：行变列，列变行arr_after[j][i] = arr_before[i][j];}printf("\n");}printf("\n");printf("转置后：\n");for (i = 0; i < arr_after_row; i++){for (j = 0; j < arr_after_col; j++){printf("%-4d",arr_after[i][j]);}printf("\n");}printf("\n");return 0;
  }

• 运行结果：