C语言数组

发表于 更新于 分类于 阅读次数： 阅读次数： 本文字数： 8.5k 阅读时长 ≈ 8 分钟
什么是数组？
数组的概念和定义

例：

1
int a[4];

这样，就在内存中分配了 4 个 int 类型的内存空间，共 4×4=16 个字节，并为它们起了一个名字， 叫 a。
我们把这样的一组数据的集合称为数组（Array） ，它所包含的每一个数据叫做数组元素（Element） ，所包含的数据的个数称为数组长度（Length） ，例如 int a[4];就定义了一个长度为 4 的整型数组，名字是 a。
数组中的每个元素都有一个序号，这个序号从 0 开始，而不是从我们熟悉的 1 开始，称为下标（Index） 。使用数组元素时，指明下标即可，形式为：

1
arrayName[index]

arrayName 为数组名称， index 为下标。例如， a[0] 表示第 0 个元素， a[3] 表示第 3 个元素。

所以数组的定义方式为：

1
dataType arrayName[length];

dataType 为数据类型， arrayName 为数组名称， length 为数组长度。

数组内存是连续的

数组是一个整体，它的内存是连续的；也就是说，数组元素之间是相互挨着的，彼此之间没有一点点缝隙。

二维数组

二维数组定义的一般形式是： 

1
dataType arrayName[length1][length2];

其中， dataType 为数据类型， arrayName 为数组名， length1 为第一维下标的长度， length2 为第二维下标的长度。
我们可以将二维数组看做一个 Excel 表格，有行有列， length1 表示行数， length2 表示列数，要在二维数组中定位某个元素，必须同时指明行和列。 例如： 

1
int a[3][4];

定义了一个 3 行 4 列的二维数组，共有 3×4=12 个元素，数组名为 a，即： 

1
a[0][0], a[0][1], a[0][2], a[0][3]

在 C 语言中，二维数组是按行排列的。 也就是先存放 a[0] 行，再存放 a[1] 行，最后存放 a[2] 行；每行中的 4 个元素也是依次存放。数组 a 为 int 类型，每个元素占用 4 个字节，整个数组共占用 4×(3×4)=48 个字节。
可以认为，二维数组是由多个长度相同的一维数组构成的。

二维数组的初始化（赋值）

二维数组的初始化可以按行分段赋值，也可按行连续赋值。

例如，对于数组 a[5][3]，按行分段赋值应该写作：

1
int a[5][3]={ {80,75,92}, {61,65,71}, {59,63,70}, {85,87,90}, {76,77,85} };

按行连续赋值应该写作：

1
int a[5][3]={80, 75, 92, 61, 65, 71, 59, 63, 70, 85, 87, 90, 76, 77, 85};

这两种赋初值的结果是完全相同的。

对于二维数组的初始化还要注意以下几点：

(1) 可以只对部分元素赋值，未赋值的元素自动取“零”值。例如：

1
int a[3][3] = {{1}, {2}, {3}};

是对每一行的第一列元素赋值，未赋值的元素的值为 0。赋值后各元素的值为：
1 0 0
2 0 0
3 0 0
再如：

1
int a[3][3] = {{0,1}, {0,0,2}, {3}};

赋值后各元素的值为：
0 1 0
0 0 2
3 0 0
(2)如果对全部元素赋值，那么第一维的长度可以不给出。例如：

1
int a[3][3] = {1, 2, 3, 4, 5, 6, 7, 8, 9};

可以写为：

1
int a[][3] = {1, 2, 3, 4, 5, 6, 7, 8, 9}

(3) 二维数组可以看作是由一维数组嵌套而成的；如果一个数组的每个元素又是一个数组，那么它就是二维数组。当
然，前提是各个元素的类型必须相同。根据这样的分析，一个二维数组也可以分解为多个一维数组， C 语言允许这种分解。
例如，二维数组 a[3][4]可分解为三个一维数组，它们的数组名分别为 

1
a[0]、 a[1]、 a[2]

这三个一维数组可以直接拿来使用。这三个一维数组都有 4 个元素，比如，一维数组 a[0] 的元素为

1
a[0][0]、 a[0][1]、a[0][2]、 a[0][3]。
C 语言字符数组和字符串
字符数组的格式

例如：

1
2
3
4
char a[10]; //一维字符数组
char b[5][10]; //二维字符数组
char c[20] = { 'c', ' ', 'p', 'r', 'o', 'g', 'r', 'a','m' }; // 给部分数组元素赋值
char d[] = { 'c', ' ', 'p', 'r', 'o', 'g', 'r', 'a', 'm' }; //对全体元素赋值时可以省去长度

字符数组实际上是一系列字符的集合，也就是字符串（String） 。在 C 语言中，没有专门的字符串变量，没有 string类型，通常就用一个字符数组来存放一个字符串。

C 语言规定，可以将字符串直接赋值给字符数组，例如： 

1
2
char str[30] = { "c.biancheng.net" }; 
char str[30] = "c.biancheng.net"; //这种形式更加简洁，实际开发中常用

数组第 0 个元素为’c’，第 1 个元素为’.’，第 2 个元素为’b’，后面的元素以此类推。

为了方便，你也可以不指定数组长度，从而写作： 

1
2
char str[] = { "c.biancheng.net" };
char str[] = "c.biancheng.net"; //这种形式更加简洁，实际开发中常用

这里需要留意一个坑，字符数组只有在定义时才能将整个字符串一次性地赋值给它，一旦定义完了，就只能一个字符一个字符地赋值了。请看下面的例子： 

1
2
3
4
5
char str[7];
str = "abc123"; //错误
//正确
str[0] = 'a'; str[1] = 'b'; str[2] = 'c';
str[3] = '1'; str[4] = '2'; str[5] = '3';
字符串结束标志

在 C 语言中，字符串总是以’\0’作为结尾，所以’\0’也被称为字符串结束标志，或者字符串结束符。

由” “包围的字符串会自动在末尾添加’\0’。 例如， “abc123”从表面看起来只包含了 6 个字符，其实不然， C 语言会在最后隐式地添加一个’\0’。

比如”C program”在内存中的存储情形：

需要注意的是，逐个字符地给数组赋值并不会自动添加’\0’，例如： 

1
char str[] = {'a', 'b', 'c'};

数组 str 的长度为 3，而不是 4，因为最后没有’\0’。
当用字符数组存储字符串时，要特别注意’\0’，要为’\0’留个位置；这意味着，字符数组的长度至少要比字符串的长度大 1。例如： 

1
char str[7] = "abc123";

“bc123”看起来只包含了 6 个字符，我们却将 str 的长度定义为 7，就是为了能够容纳最后的’\0’。如果将 str 的长度定义为 6，它就无法容纳’\0’了 。

另外，在函数内部定义的变量、数组、结构体、共用体等都称为局部数据。在很多编译器下，局部数据的初始值都是随机的、无意义的，而不是我们通常认为的“零”值。

字符串长度

字符串长度，就是字符串包含了多少个字符（不包括最后的结束符’\0’）。例如”abc”的长度是 3，而不是 4。

在 C 语言中，我们使用 string.h 头文件中的 strlen() 函数来求字符串的长度，它的用法为： 

1
length strlen(strname);

strname 是字符串的名字，或者字符数组的名字； length 是使用 strlen() 后得到的字符串长度，是一个整数。

例如：

1
2
3
4
5
6
7
8
#include <stdio.h>
#include <string.h> //记得引入该头文件
int main() {
char str[] = "wearexc.github.io";
long len = strlen(str);
printf("The lenth of the string is %ld.\n", len);
return 0;
}

运行结果：
The lenth of the string is 17.

补充：字符串的输入

在 C 语言中，有两个函数可以让用户从键盘上输入字符串，它们分别是：
scanf()：通过格式控制符%s 输入字符串。除了字符串， scanf() 还能输入其他类型的数据。
gets()：直接输入字符串，并且只能输入字符串。

但是， scanf() 和 gets() 是有区别的：

​ scanf() 读取字符串时以空格为分隔，遇到空格就认为当前字符串结束了，一般无法读取含有空格的字符串。
​ gets() 认为空格也是字符串的一部分，只有遇到回车键时才认为字符串输入结束，所以，不管输入了多少个空格，只要不按下回车键，对 gets() 来说就是一个完整的字符串。换句话说， gets() 用来读取一整行字符串。

其实 scanf() 也可以读取带空格的字符串。在C语言基础概念结尾有scanf()函数格式。

拓展：C 语言字符串处理函数

string.h 是一个专门用来处理字符串的头文件，它包含了很多字符串处理函数，由于篇幅限制，本节仅讲解几个常用的。

字符串连接函数 strcat()

strcat 是 string catenate 的缩写，意思是把两个字符串拼接在一起，语法格式为：

1
strcat(arrayName1, arrayName2);

arrayName1、 arrayName2 为需要拼接的字符串。
strcat() 将把 arrayName2 连接到 arrayName1 后面，并删除原来 arrayName1 最后的结束标志’\0’。 这意味arrayName1 必须足够长，要能够同时容纳 arrayName1 和 arrayName2，否则会越界（超出范围）。

strcat() 的返回值为 arrayName1 的地址。

例如：

1
2
3
4
5
6
7
8
9
10
11
#include <stdio.h>
#include <string.h>
int main() {
char str1[100] = "The URL is ";
char str2[60];
printf("Input a URL: ");
gets(str2);
strcat(str1, str2);
puts(str1);
return 0;
}

运行结果：

Input a URL: wearexc.github.io
The URL is wearexc.github.io

字符串复制函数 strcpy()

strcpy 是 string copy 的缩写，意思是字符串复制，也即将字符串从一个地方复制到另外一个地方，语法格式为： 

1
strcpy(arrayName1, arrayName2);

strcpy() 会把 arrayName2 中的字符串拷贝到 arrayName1 中，字符串结束标志’\0’也一同拷贝。

例如：

1
2
3
4
5
6
7
8
9
#include <stdio.h>
#include <string.h>
int main() {
char str1[50] = "随便什么东西";
char str2[50]="wearex";
strcpy(str1, str2);
printf("str1: %s\n", str1);
return 0;
}

运行结果：

str1: wearex

另外， strcpy() 要求 arrayName1 要有足够的长度，否则不能全部装入所拷贝的字符串。

字符串比较函数 strcmp()

strcmp 是 string compare 的缩写，意思是字符串比较，语法格式为：

1
strcmp(arrayName1, arrayName2);

arrayName1 和 arrayName2 是需要比较的两个字符串。
字符本身没有大小之分， strcmp() 以各个字符对应的 ASCII 码值进行比较。 strcmp() 从两个字符串的第 0 个字符开始比较，如果它们相等，就继续比较下一个字符，直到遇见不同的字符，或者到字符串的末尾。
返回值：若 arrayName1 和 arrayName2 相同，则返回 0；若 arrayName1 大于 arrayName2，则返回大于 0 的值；若 arrayName1 小于 arrayName2，则返回小于 0 的值。

例如：对4 组字符串进行比较

1
2
3
4
5
6
7
8
9
10
11
12
#include <stdio.h>
#include <string.h>
int main() {
        char a[] = "aBcDeF";
        char b[] = "AbCdEf";
        char c[] = "aacdef";
        char d[] = "aBcDeF";
        printf("a VS b: %d\n", strcmp(a, b));
        printf("a VS c: %d\n", strcmp(a, c));
        printf("a VS d: %d\n", strcmp(a, d));
    return 0;
}

运行结果：
a VS b: 32
a VS c: -31
a VS d: 0

冒泡排序法
原理和代码

对数组元素进行排序的方法有很多种，比如冒泡排序、归并排序、选择排序、 插入排序、快速排序等，其中最经典最需要掌握的是「冒泡排序」。

以从小到大排序为例，冒泡排序的整体思想是这样的：

​ 从数组头部开始，不断比较相邻的两个元素的大小，让较大的元素逐渐往后移动（交换两个元素的值），直到数组的末尾。经过第一轮的比较，就可以找到最大的元素，并将它移动到最后一个位置。

第一轮结束后，继续第二轮。仍然从数组头部开始比较，让较大的元素逐渐往后移动，直到数组的倒数第二个元素为止。经过第二轮的比较，就可以找到次大的元素，并将它放到倒数第二个位置。

以此类推，进行 n-1（n 为数组长度）轮“冒泡”后，就可以将所有的元素都排列好。

整个排序过程就好像气泡不断从水里冒出来，最大的先出来，次大的第二出来，最小的最后出来，所以将这种排序
方式称为冒泡排序（Bubble Sort） 。

下面我们以“3 2 4 1”为例对冒泡排序进行说明。

第一轮 排序过程
3 2 4 1 （最初）
2 3 4 1 （比较 3 和 2，交换）
2 3 4 1 （比较 3 和 4，不交换）
2 3 1 4 （比较 4 和 1，交换）
第一轮结束，最大的数字 4 已经在最后面，因此第二轮排序只需要对前面三个数进行比较。

第二轮 排序过程
2 3 1 4 （第一轮排序结果）
2 3 1 4 （比较 2 和 3，不交换）
2 1 3 4 （比较 3 和 1，交换）
第二轮结束，次大的数字 3 已经排在倒数第二个位置，所以第三轮只需要比较前两个元素。

第三轮 排序过程
2 1 3 4 （第二轮排序结果）
1 2 3 4 （比较 2 和 1，交换）

至此，排序结束

代码实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <stdio.h>
int main() {
int nums[10] = { 4, 5, 2, 10, 7, 1, 8, 3, 6, 9 };
int i, j, temp;
//冒泡排序算法：进行 n-1 轮比较  
    for (i = 0; i<10 - 1; i++) {
//每一轮比较前 n-1-i 个，也就是说，已经排序好的最后 i 个不用比较
for (j = 0; j<10 - 1 - i; j++) {
    if (nums[j] > nums[j + 1]) {
        temp = nums[j];
        nums[j] = nums[j + 1];
        nums[j + 1] = temp;
    }
}
}
//输出排序后的数组
for (i = 0; i<10; i++) {
    printf("%d ", nums[i]);
}
printf("\n");
return 0;
}
优化：

上面的算法是大部分教材中提供的算法，其中有一点是可以优化的：当比较到第 i 轮的时候，如果剩下的元素已经排序好了，那么就不用再继续比较了，跳出循环即可，这样就减少了比较的次数，提高了执行效率。

优化后的代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#include <stdio.h>
int main() 
{
int nums[10] = { 4, 5, 2, 10, 7, 1, 8, 3, 6, 9 };
int i, j, temp, isSorted;
//优化算法：最多进行 n-1 轮比较
for (i = 0; i<10 - 1; i++) {
    isSorted = 1; //假设剩下的元素已经排序好了
    for (j = 0; j<10 - 1 - i; j++) {
        if (nums[j] > nums[j + 1]) {
            temp = nums[j];
            nums[j] = nums[j + 1];
            nums[j + 1] = temp;
            isSorted = 0; //一旦需要交换数组元素，就说明剩下的元素没有排序好
}
}
    if (isSorted) break; //如果没有发生交换，说明剩下的元素已经排序好了
}
for (i = 0; i<10; i++) {
    printf("%d ", nums[i]);
    }
    printf("\n");
return 0;
}