一、数组的概念
有如下几组数据：
- 学生的学习成绩
- 银行的账单
- 一行文字
这些数据的特点是：
- 具有相同的数据类型；
- 使用过程中需要保留原始数据 。
C语言为这类数据，提供了一种构造数据类型——数组。
在程序设计中，为了处理方便，把具有相同类型的若干变量按有序的形式组织起来，这些按序排列的同类数据元素的集合称为数组。 在C语言中，数组属于构造数据类型； 数组元素有序不是指元素大小顺序，而是位置顺序。
简而言之，数组就是具有相同类型的数据组成的序列，是一个有序集合。 数组中的每一个数据称为数组元素，也称为下标变量，即每个元素由其所在的位置序号（即数组元素的下标）来区分。 用数组名与下标可以用统一的方式来处理数组中的所有元素，从而方便地实现处理一批具有相同性质的数据的问题。
一个数组可以分解为多个数组元素，这些数组元素可以是基本数据类型或是构造类型，因此按数组元素的类型不同，数组又可分为数值数组、字符数组、指针数组、结构数组等类别。
二、一维数组的定义与引用
1.一维数组定义
在C语言中使用数组必须先进行定义。 一维数组的定义方式为：
1类型说明符 数组名[常量表达式];
例如int a[10]定义了一个整型数组，数组名为a，此数组有10个元素，10个元素都是整型变量。
注意事项
（1）类型说明符是任一种基本数据类型或构造数据类型，对于同一个数组，其所有元素的数据类型都是相同的。
（2）数组名是用户定义的数组标识符，书写规则应符合标识符的书写规定。
（3）方括号中的常量表达式表示数据元素的个数，也称为数组的长度。
（4）允许在同一个类型说明中，说明多个数组和多个变量。
例如int a, b, c, d, k1[10], k2[20];。
（5）a[10]表示a数组有10个元素，下标从0开始，这10个元素是a[0]、a[1]、…、a[9]。
因此，不存在数组元素a[10]。
（6）C语言不允许对数组的大小作动态定义，即数组的大小不依赖于程序运行过程中变量的值，因为在编译的时候就要为数组预留空间，所以在编写代码的时候不能通过变量来定义数组的大小。 例如，下面这样定义数组是不行的：
1int n; 2scanf("%d"，&n); /* 在程序中临时输入数组的大小 */ 3int a[n];
常见错误
1float a[0]; /* 数组大小为0没有意义 */ 2int b(2)(3); /* 不能使用圆括号 */ 3int k, a[k]; /* 不能用变量说明数组大小 */
正确示意如下：
1int a[10]; // 声明整型数组a，有10个元素。 2float b[10],c[20]; // 声明实型数组b，有10个元素，实型数组c，有20个元素。 3char ch[20]; // 声明字符数组ch，有20个元素。
扩展：一维数组在内存中的存放
定义一个一维数组int mark[100];，其在内存中地存放原理如下：
2.一维数组的引用
数组元素是组成数组的基本单元，也是一种变量，其标识方法为数组名后跟一个下标，下标表示了元素在数组中的顺序号。
引用数组元素的一般形式为数组名[下标]，下标可以是整型常量或整型表达式。
例如:
1a[0] = a[5] + a[7] - a[2*3]; 2a[i+j]; 3a[i++];
这些都是合法的数组元素引用。
注意事项
（1）数组元素通常也称为下标变量，必须先定义数组，才能使用下标变量。 在C语言中只能逐个地使用下标变量，而不能一次引用整个数组。 例如，输出有10个元素的数组必须使用循环语句逐个输出，示意如下：
1#include <stdio.h> 2 3int main(){ 4 int i, a[10]; 5 for(i = 0;i < 10; i++){ 6 a[i] = i; 7 } 8 for(i = 9;i >= 0;i--){ 9 printf("%d ", a[i]); 10 } 11 12 return 0; 13}
打印：
19 8 7 6 5 4 3 2 1 0
不能用一个语句输出整个数组，printf("%d",a);写法是错误的。
（2）定义数组时用到的数组名[常量表达式]和引用数组元素时用到的数组名[下标]是有区别的。
例如∶
1int a[10]; /* 定义数组长度为10 */ 2t = a[6]; /* 引用a数组中序号为6的元素，此时6不代表数组长度 */
显然，两者的含义是不一样的。
3.一维数组的初始化
给数组赋值的方法除了用赋值语句对数组元素逐个赋值外，还可采用初始化赋值和动态赋值的方法。 数组初始化赋值是指在数组定义时给数组元素赋初值。 数组初始化是在编译阶段进行的，这样将减少运行时间，提高效率； 之前用赋值语句或输入语句也可给数组素指定初值，是在运行时完成。
初始化赋值
初始化赋值的一般形式为：
1类型说明符 数组名[常量表达式] = {值, 值, …, 值};
具体的实现方法有以下几种：
（1）在定义数组时对数组元素赋以初值。
例如int a［10］= {0，1，2，3，4，5，6，7，8，9};，将数组元素的初值依次放在一对大括号内。
经过上面的定义和初始化之后，得到a[0] = 0，a[1] = 1，…，a[9] = 9。
测试如下：
1#include <stdio.h> 2 3int main(){ 4 int i, a[10] = {0, 1, 2, 3, 4, 5, 6, 7 ,8 ,9}; 5 for(i = 9;i >= 0;i--){ 6 printf("%d ", a[i]); 7 } 8 9 return 0; 10}
与之前的效果是一样的。
（2）可以只给一部分元素赋值。
例如int a[10] = {0，1，2，3，4};定义a数组有10个元素，但大括号内只提供5个初值，这表示只给前面5个元素赋初值，后5个元素值为0。
测试如下：
1#include <stdio.h> 2 3int main(){ 4 int i, a[10] = {0, 1, 2, 3, 4}; 5 for(i = 9;i >= 0;i--){ 6 printf("%d ", a[i]); 7 } 8 9 return 0; 10}
打印：
10 0 0 0 0 4 3 2 1 0
显然，未定义的元素默认为0。
（3）如果想要使一个数组中全部元素值为0，可以写成int a[10] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};或int a[10] = {0};。
（4）在对全部数组元素赋初值时，由于数据的个数已经确定，因此可以不指定数组长度。
例如int a[5] = {1, 2, 3, 4, 5};也可以写成int a[] = {1, 2, 3, 4, 5};。
在第二种写法中，大括号中有5个数，系统就会据此自动定义a数组的长度为5。
如果数组长度与提供初值的个数不相同，则数组长度不能省略。
例如，想定义数组长度为10，就不能省略数组长度的定义，而必须写成int a[10] = {1, 2, 3, 4, 5}; 只初始化前5个元素，后5个元素为0。
数组初始化与未初始化比较测试如下：
1#include <stdio.h> 2 3int main(){ 4 int i, a[5] = {3, 4, 5}, b[5]; 5 printf("Array a is:\n"); 6 for(i = 0;i < 5;i++){ 7 printf("%8d", a[i]); 8 } 9 printf("\nArray b is:\n"); 10 for(i = 0;i < 5;i++){ 11 printf("%8d", b[i]); 12 } 13 14 return 0; 15}
打印：
1Array a is: 2 3 4 5 0 0 3Array b is: 4 -1 -1 4236709 0 1
显然，b数组未赋值，所以打印出了很乱、看不出规律的值。
动态赋值
动态赋值的方法示例如下：
1#include <stdio.h> 2 3int main(){ 4 int i, max, a[10]; 5 printf("Input 10 numbers:\n"); 6 for(i = 0;i < 10;i++){ 7 scanf("%d", &a[i]); 8 } 9 max = a[0]; 10 for(i = 1;i < 10;i++){ 11 if(a[i] > max){ 12 max = a[i]; 13 } 14 } 15 printf("max=%d", max); 16 17 return 0; 18}
打印：
1Input 10 numbers: 213 346 470 595 673 725 862 978 1054 119 12max=95
显然，在输入10个数给数组赋值后，打印出了最大值。
练习： 利用数组来求解Fibonacci数列前20个数。 代码如下：
1#include <stdio.h> 2 3int main(){ 4 int i; 5 int a[20] = {1, 1}; 6 for(i = 2;i < 20;i++){ 7 a[i] = a[i - 1] + a[i - 2]; 8 } 9 10 for(i = 0;i < 20;i++){ 11 printf("%6d", a[i]); 12 if(i % 5 == 4){ 13 printf("\n"); 14 } 15 } 16 17 return 0; 18}
打印：
1 1 1 2 3 5 2 8 13 21 34 55 3 89 144 233 377 610 4 987 1597 2584 4181 6765
练习： 用冒泡法(起泡法)对10个数排序(由小到大)。 代码如下：
1#include <stdio.h> 2 3int main(){ 4 int i, j; 5 int a[10]; 6 for(i = 0;i < 10;i++){ 7 scanf("%d", &a[i]); 8 } 9 10 for(i = 9;i >= 1;i--){ 11 for(j = 0;j < i;j++){ 12 int temp; 13 if(a[j] > a[j + 1]){ 14 temp = a[j]; 15 a[j] = a[j + 1]; 16 a[j + 1] = temp; 17 } 18 } 19 } 20 printf("The sorted nubers:\n"); 21 for(i = 0;i < 10;i++){ 22 printf("%d ", a[i]); 23 } 24 25 return 0; 26}
打印：
112 37 65 43 97 82 120 63 9 17 2The sorted nubers: 39 12 17 37 43 63 65 82 97 120
显然，最后得到的就是已经排好序的数组。
三、二维数组的定义和引用
1.二维数组的定义
二维数组定义的一般形式为：
1类型说明符 数组名[常量表达式][常量表达式];
例如:定义a为3X4 (3行4列)的数组，b为5X10(5行10列)的数组，如下:
1float a[3][4], b[5][10];
不能写成
1float a[3, 4], b[5, 10];
二维数组可理解为元素是一维数组的一维数组，例如int a[3][4];理解如下：
多维数组的定义：
例如float a[2][3][4];。
二维数组在内存中的存放方式示意如下：
三维数组在内存中的存放方式示意如下：
2.二维数组的引用和初始化
引用数组元素的表示形式：
1数组名[下标][下标]
其中，下标可以是整型常量或整型表达式。 如
1int a[4][3], i=2, j=1; 2a[2][3]; 3a[i][j]; 4a[i+1][2*j-1];
但a[i, j]就是错误的。
初始化数组的形式为：
1数据类型 数组名[常量表达式1][常量表达式2] = {初始化数据};
有4种方法对二维数组初始化：
（1）直接分行给二维数组赋初值。
如int a[3][4] = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};。
（2）可以将所有数据写在一个大括号内，按数组排列的顺序对各元素赋初值。
如int a[3][4] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};。
（3）可以对部分元素赋初值。
如int a[3][4]={{1}, {5}, {9}};，存放如下：
而int a[3][4] = {1, 5, 9}是给a数组的第一个子数组a[0]的前3个元素赋值，与前者不一样。
也可以对各行中的某一或某些元素赋初值。
如int a[3][4]={{1}, {0, 6}, {0, 0, 11}};，存放如下：
还可以只对某几行元素赋初值。
如int a[4][4]={{1}, {5, 6}};，存放如下：
（4）如果对全部元素都赋初值，则定义数组时对第一维的长度可以不指定，但第二维的长度不能省。
如，int a[3][4] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};等价于int a[][4] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};。
在定义时也可以只对部分元素赋初值而省略第一维的长度，但应分行赋初值。
如int a[][4] ={{0, 0, 3}, {}, {0, 10}};，存放如下：
练习：
如下图，一个学习小组有5个人，每个人有三门课的考试成绩。将各个数据保存到二维数组a[5][3]中，并求全组分科的平均成绩和总平均成绩。
代码如下：
1#include <stdio.h> 2 3int main(){ 4 int i, j; 5 double savg[3]; 6 int a[5][3] = {{80, 75, 92}, {61, 65, 71}, {59, 63, 70}, {85, 87 ,90}, {76, 77, 85}}; 7 for(i = 0;i < 3;i++){ 8 int sum = 0; 9 for(j = 0;j < 5;j++){ 10 sum += a[j][i]; 11 } 12 savg[i] = sum / 5.0; 13 } 14 int tavg = 0; 15 for(i=0;i<3;i++){ 16 printf("Average Grade:%.2f\n", savg[i]); 17 tavg += savg[i]; 18 } 19 printf("Total AVerage Grade is:%.2f", tavg / 3.0); 20 21 return 0; 22}
打印：
1Average Grade:72.20 2Average Grade:73.40 3Average Grade:81.60 4Total AVerage Grade is:75.33
练习：
将一个二维数组行和列元素互换，存到另一个二维数组中。
例如，将数组a[2][3]转化为数组b[3][2]如下：
代码：
1#include <stdio.h> 2 3int main(){ 4 int i, j; 5 int a[5][3] = {{80, 75, 92}, {61, 65, 71}, {59, 63, 70}, {85, 87 ,90}, {76, 77, 85}}, b[3][5]; 6 printf("Array A:\n"); 7 for(i = 0;i < 3;i++){ 8 for(j = 0;j < 5;j++){ 9 printf("%4d", a[j][i]); 10 b[i][j] = a[j][i]; 11 } 12 printf("\n"); 13 } 14 printf("Arary B:\n"); 15 for(i = 0;i < 5;i++){ 16 for(j = 0;j < 3;j++){ 17 printf("%4d", b[j][i]); 18 } 19 printf("\n"); 20 } 21 22 return 0; 23}
打印：
1Array A: 2 80 61 59 85 76 3 75 65 63 87 77 4 92 71 70 90 85 5Arary B: 6 80 75 92 7 61 65 71 8 59 63 70 9 85 87 90 10 76 77 85 11
练习： 有一个矩阵，要求编写程序求出其中最大的元素，以及其所在的行号和列号。 代码如下：
1#include <stdio.h> 2 3int main(){ 4 int i, j, row = 0, column = 0, max = 0; 5 int a[5][3] = {{80, 75, 92}, {61, 65, 71}, {59, 63, 70}, {85, 87 ,90}, {76, 77, 85}}; 6 max = a[0][0]; 7 for(i = 0;i < 3;i++){ 8 for(j = 0;j < 5;j++){ 9 if(a[j][i] > max){ 10 max = a[j][i]; 11 row = j; 12 column = i; 13 } 14 } 15 } 16 printf("Max=%d, in row %d column %d", max, row, column); 17 18 return 0; 19}
打印：
1Max=92, in row 0 column 2
练习：
从键盘上输入9个整数，(对照九宫格的形式，输入三行，每行输入三个数) 保存在二维数组中，按数组原来位置输出第一行和第一列的所有元素。
如果数组如下：
则输出为：
代码如下：
1#include <stdio.h> 2 3int main(){ 4 int i, j, a[3][3]; 5 for(i = 0;i<3;i++){ 6 for(j = 0;j<3;j++){ 7 printf("a[%d][%d] = ", i, j); 8 scanf("%d", &a[i][j]); 9 } 10 } 11 for(i=0;i<3;i++){ 12 for(j=0;j<3;j++){ 13 if(i == 1 || j == 1){ 14 printf("%-6d", a[i][j]); 15 } 16 else{ 17 printf("%-6c", ' '); 18 } 19 } 20 printf("\n"); 21 } 22 23 return 0; 24}
打印：
1a[0][0] = 12 2a[0][1] = 34 3a[0][2] = 56 4a[1][0] = 78 5a[1][1] = 90 6a[1][2] = 98 7a[2][0] = 76 8a[2][1] = 54 9a[2][2] = 43 10 34 1178 90 98 12 54 13
四、数组的应用：二分法
利用数组进行数据查找——二分法（也叫折半查找法）： 适应情况： 在一批有序数据中查找某数； 基本思想： 选定这批数中居中间位置的一个数与所查数比较，看是否为所找之数，若不是，利用数据的有序性，可以决定所找的数是在选定数之前还是在之后，从而很快可以将查找范围缩小一半。以同样的方法在选定的区域中进行查找，每次都会将查找范围缩小一半，从而较快地找到目的数。
练习：
假设在数组a中的数据是按由小到大顺序排列的：
-12 0 6 16 23 56 80 100 110 115。
从键盘上输入一个数，判定该数是否在数组中，若在，输出所在序号。
实现思路：
- 设low、mid和high三个变量，分别指示数列中的起始元素、中间元素与最后一个元素位置，其初始值为low=0,high=9,mid=4，判断mid指示的数是否为所求，mid指示的数是23，不是要找的80，须继续进行查找。
- 确定新的查找区间。因为80大于23，所以查找范围可以缩小为23后面的数，新的查找区间为[56 80 100 110 115]，low、mid、high分别指向新区间的开始、中间与最后一个数。实际上high不变，将low（low=mid+1）指向56，mid （mid=(low+high)/2）指向100，还不是要找的80，仍须继续查找。
- 上一步中，所找数80比mid指示的100小，可知新的查找区间为[56 80]，low不变，mid与high的值作相应修改。mid指示的数为56，还要继续查找。
- 根据上一步的结果，80大于mid指示的数56，可确定新的查找区间为[80]，此时，low与high都指向80，mid亦指向80，即找到了80，到此为止，查找过程完成。
注意： 若在查找过程中，出现low > high的情况，则说明序列中没有该数，亦结束查找过程。
代码如下：
1#include <stdio.h> 2#define M 10 3 4int main(){ 5 static int a[M] = {-12, 0, 6, 16, 23, 56, 80, 100, 110, 115}; // 定义静态变量 6 int n, low = 0, mid, high = M - 1, found = 0; 7 printf("Input a number to be searched:\n"); 8 scanf("%d", &n); 9 while(low <= high){ 10 mid = (low + high) / 2; 11 if( n== a[mid]){ 12 found = 1; 13 break; 14 } 15 else if(n > a[mid]){ 16 low = mid + 1; 17 } 18 else{ 19 high = mid - 1; 20 } 21 } 22 if(found == 1){ 23 printf("The number %d is found, and the index is %d\n", n, mid); 24 } 25 else{ 26 printf("The number %d is not found\n", n); 27 } 28 29 return 0; 30}
打印：
1Input a number to be searched: 280 3The number 80 is found, and the index is 6 4
可以看到，在程序中定义了一个静态变量； C程序在编译时，普通变量存放在栈区，static关键字会使变量存放在data区。
补充知识——内存分为四大区：
- code区 写的代码存放的地方。
- data区 常量、字符串和static声明的变量存放的地方，特点是不会改变，整个程序结束之后才会释放。
- stack区 普通变量存放的地方，函数调用完成后就会释放。
- heap区 malloc函数定义，由开发者自己分配。
还可以进一步优化： 如果输入的数大于最大的数或小于最小的数，说明这个有序序列中不存在要寻找的数，可以直接不用循环查找，改进如下：
1#include <stdio.h> 2#define M 10 3 4int main(){ 5 static int a[M] = {-12, 0, 6, 16, 23, 56, 80, 100, 110, 115}; 6 int n, low = 0, mid, high = M - 1, found = 0; 7 printf("Input a number to be searched:\n"); 8 scanf("%d", &n); 9 if(n < a[0] || n > a[M - 1]){ 10 while(low <= high){ 11 mid = (low + high) / 2; 12 if( n== a[mid]){ 13 found = 1; 14 break; 15 } 16 else if(n > a[mid]){ 17 low = mid + 1; 18 } 19 else{ 20 high = mid - 1; 21 } 22 } 23 if(found == 1){ 24 printf("The number %d is found, and the index is %d\n", n, mid); 25 } 26 else{ 27 printf("The number %d is not found\n", n); 28 } 29 } 30 else{ 31 printf("Illegal Input!!!"); 32 } 33 34 return 0; 35}
打印：
1Input a number to be searched: 2a 3Illegal Input!!!
显然，此时可以识别非法输入。 也可以改进如下：
1#include <stdio.h> 2#define M 10 3 4int main(){ 5 static int a[M] = {-12, 0, 6, 16, 23, 56, 80, 100, 110, 115}; 6 int n, low = 0, mid, high = M - 1, found = 0; 7 printf("Input a number to be searched:\n"); 8 scanf("%d", &n); 9 while(scanf("%d", &n) != 1){ 10 printf("Illegal Input!!\nPlease Input Again!!\n"); 11 getchar(); 12 } 13 while(low <= high){ 14 mid = (low + high) / 2; 15 if( n== a[mid]){ 16 found = 1; 17 break; 18 } 19 else if(n > a[mid]){ 20 low = mid + 1; 21 } 22 else{ 23 high = mid - 1; 24 } 25 } 26 if(found == 1){ 27 printf("The number %d is found, and the index is %d\n", n, mid); 28 } 29 else{ 30 printf("The number %d is not found\n", n); 31 } 32 33 return 0; 34}
打印：
1Input a number to be searched: 2a 3Illegal Input!! 4Please Input Again!! 5bc 6Illegal Input!! 7Please Input Again!! 8Illegal Input!! 9Please Input Again!! 1012 11The number 12 is not found 12
显然，此时如果输入有误，会提示再输入，直到输入合法，再向下执行并判断。
本文原文首发来自博客专栏C语言学习，由本人转发至https://www.helloworld.net/p/YVwtJ1u9MU6Z，其他平台均属侵权，可点击https://blog.csdn.net/CUFEECR/article/details/105783152查看原文，也可点击https://blog.csdn.net/CUFEECR浏览更多优质原创内容。