【C语言学习】数组
数组（Array）就是一些列具有相同类型的数据的集合，这些数据在内存中依次挨着存放，彼此之间没有缝隙。
数组不是C语言的专利，Java、C++、C#、JavaScript、PHP 等其他编程语言也有数组。
C语言数组属于构造数据类型。一个数组可以分解为多个数组元素，这些数组元素可以是基本数据类型或是构造类型。因此按数组元素的类型不同，数组又可分为数值数组、字符数组、指针数组、结构数组等各种类别。
基本概念
数组的概念和定义
要想把数据放入内存，必须先要分配内存空间。放入4个整数，就得分配4个int类型的内存空间：
int a[4];
这样，就在内存中分配了4个int类型的内存空间，共 4×4=16 个字节，并为它们起了一个名字，叫a。
我们把这样的一组数据的集合称为数组（Array），它所包含的每一个数据叫做数组元素（Element），所包含的数据的个数称为数组长度（Length），例如int a[4];就定义了一个长度为4的整型数组，名字是a。
数组中的每个元素都有一个序号，这个序号从0开始，而不是从我们熟悉的1开始，称为下标（Index）。使用数组元素时，指明下标即可，形式为：
arrayName[index]
#include
int main(){
int nums[10];
int i;
//将1~10放入数组中
for(i=0; i<10; i++){
nums[i] = (i+1);
}
//依次输出数组元素
for(i=0; i<10; i++){
printf("%d ", nums[i]);
}
return 0;
}
//1 2 3 4 5 6 7 8 9 10
更改上面的代码，让用户输入 10 个数字并放入数组中：
#include
int main(){
int nums[10];
int i;
//从控制台读取用户输入
for(i=0; i<10; i++){
scanf("%d", &nums[i]); //注意取地址符 &，不要遗忘哦
}
//依次输出数组元素
for(i=0; i<10; i++){
printf("%d ", nums[i]);
}
return 0;
}
/*
22 18 928 5 4 82 30 10 666 888↙
22 18 928 5 4 82 30 10 666 888
*/
总结一下数组的定义方式：
dataType arrayName[length];
dataType 为数据类型，arrayName 为数组名称，length 为数组长度。例如：
float m[12]; //定义一个长度为 12 的浮点型数组
char ch[9]; //定义一个长度为 9 的字符型数组
需要注意的是：
-
数组中每个元素的数据类型必须相同，对于
int a[4];，每个元素都必须为 int。 -
数组长度 length 最好是整数或者常量表达式，例如 10、204 等，这样在所有编译器下都能运行通过；如果 length 中包含了变量，例如 n、4m 等，在某些编译器下就会报错。
-
访问数组元素时，下标的取值范围为 0 ≤ index < length，过大或过小都会越界，导致数组溢出，发生不可预测的情况
数组内存是连续的
数组是一个整体，它的内存是连续的；也就是说，数组元素之间是相互挨着的，彼此之间没有一点点缝隙。
下图演示了int a[4];在内存中的存储情形：
「数组内存是连续的」这一点很重要。连续的内存为指针操作（通过指针来访问数组元素）和内存处理（整块内存的复制、写入等）提供了便利，这使得数组可以作为缓存（临时存储数据的一块内存）使用。
数组的初始化
在定义数组的同时赋值，例如：
int a[4] = {20, 345, 700, 22};
数组元素的值由{ }包围，各个值之间以,分隔。
对于数组的初始化需要注意以下几点：
- 可以只给部分元素赋值。当
{ }中值的个数少于元素个数时，只给前面部分元素赋值。例如：
int a[10]={12, 19, 22 , 993, 344};
当赋值的元素少于数组总体元素的时候，剩余的元素自动初始化为 0：
-
对于short、int、long，就是整数 0；
-
对于char，就是字符 ‘\0’；
-
对于float、double，就是小数 0.0。
可以通过下面的形式将数组的所有元素初始化为 0：
int nums[10] = {0};
char str[10] = {0};
float scores[10] = {0.0};
由于剩余的元素会自动初始化为 0，所以只需要给第 0 个元素赋值为 0 即可。
- 只能给元素逐个赋值，不能给数组整体赋值。例如给 10 个元素全部赋值为 1，只能写作：
int a[10] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
而不能写作：
int a[10] = 1;
- 如给全部元素赋值，那么在定义数组时可以不给出数组长度。例如：
int a[] = {1, 2, 3, 4, 5};
等价于
int a[5] = {1, 2, 3, 4, 5};
借助数组来输出一个 4×4 的矩阵：
#include
int main()
{
int a[4] = {20, 345, 700, 22};
int b[4] = {56720, 9999, 20098, 2};
int c[4] = {233, 205, 1, 6666};
int d[4] = {34, 0, 23, 23006783};
printf("%-9d %-9d %-9d %-9d\n", a[0], a[1], a[2], a[3]);
printf("%-9d %-9d %-9d %-9d\n", b[0], b[1], b[2], b[3]);
printf("%-9d %-9d %-9d %-9d\n", c[0], c[1], c[2], c[3]);
printf("%-9d %-9d %-9d %-9d\n", d[0], d[1], d[2], d[3]);
return 0;
}
二维数组
二维数组的定义
二维数组定义的一般形式是：
dataType arrayName[length1][length2];
其中，dataType 为数据类型，arrayName 为数组名，length1 为第一维下标的长度，length2 为第二维下标的长度。
**我们可以将二维数组看做一个 Excel 表格，有行有列，length1 表示行数，length2 表示列数，要在二维数组中定位某个元素，必须同时指明行和列。**例如：
定义了一个 3 行 4 列的二维数组，共有 3×4=12 个元素，数组名为 a，即：
a[0][0], a[0][1], a[0][2], a[0][3]
a[1][0], a[1][1], a[1][2], a[1][3]
a[2][0], a[2][1], a[2][2], a[2][3]
如果想表示第 2 行第 1 列的元素，应该写作 a[2][1]。
也可以将二维数组看成一个整数坐标系，有 x 轴和 y 轴，要想在一个平面中确定一个点，必须同时知道 x 轴和 y 轴。
二维数组在概念上是二维的，但在内存中是连续存放的；换句话说，二维数组的各个元素是相互挨着的，彼此之间没有缝隙。那么，如何在线性内存中存放二维数组呢？有两种方式：
-
一种是按行排列， 即放完一行之后再放入第二行；
-
另一种是按列排列， 即放完一列之后再放入第二列。
**在C语言中，二维数组是按行排列的。**也就是先存放 a[0] 行，再存放 a[1] 行，最后存放 a[2] 行；每行中的 4 个元素也是依次存放。数组 a 为 int 类型，每个元素占用 4 个字节，整个数组共占用 4×(3×4)=48 个字节。
一个学习小组有 5 个人，每个人有 3 门课程的考试成绩，求该小组各科的平均分和总平均分。
可以定义一个二维数组 a[5][3] 存放 5 个人 3 门课的成绩，定义一个一维数组 v[3] 存放各科平均分，再定义一个变量 average 存放总平均分。
#include
int main(){
int i, j; //二维数组下标
int sum = 0; //当前科目的总成绩
int average; //总平均分
int v[3]; //各科平均分
int a[5][3]; //用来保存每个同学各科成绩的二维数组
printf("Input score:\n");
for(i=0; i<3; i++){
for(j=0; j<5; j++){
scanf("%d", &a[j][i]); //输入每个同学的各科成绩
sum += a[j][i]; //计算当前科目的总成绩
}
v[i]=sum/5; // 当前科目的平均分
sum=0;
}
average = (v[0] + v[1] + v[2]) / 3;
printf("Math: %d\nC Languag: %d\nEnglish: %d\n", v[0], v[1], v[2]);
printf("Total: %d\n", average);
return 0;
}
/*
Input score:
80 61 59 85 76 75 65 63 87 77 92 71 70 90 85↙
Math: 72
C Languag: 73
English: 81
Total: 75
*/
二维数组的初始化（赋值）
二维数组的初始化可以按行分段赋值，也可按行连续赋值。
例如，对于数组 a[5][3]，按行分段赋值应该写作：
int a[5][3]={ {80,75,92}, {61,65,71}, {59,63,70}, {85,87,90}, {76,77,85} };
按行连续赋值应该写作：
int a[5][3]={80, 75, 92, 61, 65, 71, 59, 63, 70, 85, 87, 90, 76, 77, 85};
这两种赋初值的结果是完全相同的。
#include
int main(){
int i, j; //二维数组下标
int sum = 0; //当前科目的总成绩
int average; //总平均分
int v[3]; //各科平均分
int a[5][3] = {{80,75,92}, {61,65,71}, {59,63,70}, {85,87,90}, {76,77,85}};
for(i=0; i<3; i++){
for(j=0; j<5; j++){
sum += a[j][i]; //计算当前科目的总成绩
}
v[i] = sum / 5; // 当前科目的平均分
sum = 0;
}
average = (v[0] + v[1] + v[2]) / 3;
printf("Math: %d\nC Languag: %d\nEnglish: %d\n", v[0], v[1], v[2]);
printf("Total: %d\n", average);
return 0;
}
/*
Math: 72
C Languag: 73
English: 81
Total: 75
*/
对于二维数组的初始化还要注意以下几点：
- 可以只对部分元素赋值，未赋值的元素自动取“零”值。例如：
int a[3][3] = {{1}, {2}, {3}};
是对每一行的第一列元素赋值，未赋值的元素的值为 0。赋值后各元素的值为：
1 0 0
2 0 0
3 0 0
再如：
int a[3][3] = {{0,1}, {0,0,2}, {3}};
赋值后各元素的值为：
0 1 0
0 0 2
3 0 0
- 如果对全部元素赋值，那么第一维的长度可以不给出。例如：
int a[3][3] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
可以写为：
int a[][3] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
- 二维数组可以看作是由一维数组嵌套而成的；如果一个数组的每个元素又是一个数组，那么它就是二维数组。当然，前提是各个元素的类型必须相同。根据这样的分析，一个二维数组也可以分解为多个一维数组，C语言允许这种分解。
例如，二维数组a[3][4]可分解为三个一维数组，它们的数组名分别为 a[0]、a[1]、a[2]。
这三个一维数组可以直接拿来使用。这三个一维数组都有 4 个元素，比如，一维数组 a[0] 的元素为 a[0][0]、a[0][1]、a[0][2]、a[0][3]。
判断数组中是否包含某个元素
对无序数组的查询
所谓无序数组，就是数组元素的排列没有规律。无序数组元素查询的思路也很简单，就是用循环遍历数组中的每个元素，把要查询的值挨个比较一遍。
#include
int main() {
int nums[10] = {1, 10, 6, 296, 177, 23, 0, 100, 34, 999};
int i, num, this_index = -1;
printf("Input an integer: ");
scanf("%d", &num);
for (i = 0; i < 10; i++) {
if (nums[i] == num) {
this_index = i;
break;
}
}
if (this_index < 0) {
printf("%d isn't in the array.\n", num);
} else {
printf("%d is in the array, it's index is %d.\n", num, this_index);
}
return 0;
}
/*
Input an integer: 100↙
100 is in the array, it's index is 7.
或者
Input an integer: 28↙
28 isn't in the array.
*/
数组下标的取值范围是非负数，当 thisindex >= 0 时，该数字在数组中，当 thisindex < 0 时，该数字不在数组中，所以在定义 thisindex 变量时，必须将其初始化为一个负数。
对有序数组的查询
#include
int main() {
int nums[10] = {0, 1, 6, 10, 23, 34, 100, 177, 296, 999};
int i, num, this_index = -1;
printf("Input an integer: ");
scanf("%d", &num);
for (i = 0; i < 10; i++) {
if (nums[i] == num) {
this_index = i;
break;
} else if (nums[i] > num) break;
}
if (this_index < 0) {
printf("%d isn't in the array.\n", num);
} else {
printf("%d is in the array, it's index is %d.\n", num, this_index);
}
return 0;
}
与前面的代码相比，这段代码的改动很小，只增加了一个判断语句，也就是 12~14 行。因为数组元素是升序排列的，所以当 nums[i] > num 时，i 后边的元素也都大于 num 了，num 肯定不在数组中了，就没有必要再继续比较了，终止循环即可。
二分查找的原型。
字符数组和字符串
用来存放字符的数组称为字符数组，例如：
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语言规定，可以将字符串直接赋值给字符数组，例如：
char str[30] = {"c.biancheng.net"};
char str[30] = "c.biancheng.net"; //这种形式更加简洁，实际开发中常用
数组第 0 个元素为'c'，第 1 个元素为'.'，第 2 个元素为'b'，后面的元素以此类推。
为了方便，你也可以不指定数组长度，从而写作：
char str[] = {"c.biancheng.net"};
char str[] = "c.biancheng.net"; //这种形式更加简洁，实际开发中常用
给字符数组赋值时，通常使用将字符串一次性地赋值（可以指明数组长度，也可以不指明）这种写法。
字符数组只有在定义时才能将整个字符串一次性地赋值给它，一旦定义完了，就只能一个字符一个字符地赋值了。
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'是 ASCII 码表中的第 0 个字符，英文称为 NUL，中文称为“空字符”。该字符既不能显示，也没有控制功能，输出该字符不会有任何效果，它在C语言中唯一的作用就是作为字符串结束标志。
C语言在处理字符串时，会从前往后逐个扫描字符，一旦遇到'\0'就认为到达了字符串的末尾，就结束处理。'\0'至关重要，没有'\0'就意味着永远也到达不了字符串的结尾。
由" "包围的字符串会自动在末尾添加'\0'。例如，"abc123"从表面看起来只包含了 6 个字符，其实不然，C语言会在最后隐式地添加一个'\0'，这个过程是在后台默默地进行的，所以我们感受不到。
下图演示了"C program"在内存中的存储情形：
需要注意的是，逐个字符地给数组赋值并不会自动添加'\0'，例如：
char str[] = {'a', 'b', 'c'};
数组 str 的长度为 3，而不是 4，因为最后没有'\0'。
当用字符数组存储字符串时，要特别注意'\0'，要为'\0'留个位置；这意味着，字符数组的长度至少要比字符串的长度大 1：
char str[7] = "abc123";
"abc123"看起来只包含了 6 个字符，我们却将 str 的长度定义为 7，就是为了能够容纳最后的'\0'。如果将 str 的长度定义为 6，它就无法容纳'\0'了。
有些时候，程序的逻辑要求我们必须逐个字符地为数组赋值，这个时候就很容易遗忘字符串结束标志'\0'。下面的代码中，我们将 26 个大写英文字符存入字符数组，并以字符串的形式输出：
#include
int main(){
char str[30];
char c;
int i;
for(c=65,i=0; c<=90; c++,i++){
str[i] = c;
}
printf("%s\n", str);
return 0;
}
在 VS2015 下的运行结果：
ABCDEFGHIJKLMNOPQRSTUVWXYZ口口口口i口口0 ?
口表示无法显示的特殊字符。
**在很多编译器下，局部变量的初始值是随机的，是垃圾值，而不是我们通常认为的“零”值。**局部数组（在函数内部定义的数组，本例中的 str 数组就是在 main() 函数内部定义的）也有这个问题，很多编译器并不会把局部数组的内存都初始化为“零”值，而是放任不管，爱是什么就是什么，所以它们的值也是没有意义的，也是垃圾值。
在函数内部定义的变量、数组、结构体、共用体等都称为局部数据。在很多编译器下，局部数据的初始值都是随机的、无意义的，而不是我们通常认为的“零”值。
本例中的 str 数组在定义完成以后并没有立即初始化，所以它所包含的元素的值都是随机的，只有很小的概率会是“零”值。循环结束以后，str 的前 26 个元素被赋值了，剩下的 4 个元素的值依然是随机的，不知道是什么。
printf() 输出字符串时，会从第 0 个元素开始往后检索，直到遇见'\0'才停止，然后把'\0'前面的字符全部输出，这就是 printf() 输出字符串的原理。本例中我们使用 printf() 输出 str，按理说到了第 26 个元素就能检索到'\0'，就到达了字符串的末尾，然而事实却不是这样，由于我们并未对最后 4 个元素赋值，所以第 26 个元素不是'\0'，第 27 个也不是，第 28 个也不是……可能到了第 50 个元素才遇到'\0'，printf() 把这 50 个字符全部输出出来，就是上面的样子，多出来的字符毫无意义，甚至不能显示。
数组总共才 30 个元素，到了第 50 个元素早就超出数组范围了。然而，数组后面依然有其它的数据，printf() 也会将这些数据作为字符串输出。
要想避免这些问题，需要在字符串的最后手动添加'\0'即可。修改上面的代码，在循环结束后添加'\0'：
#include
int main(){
char str[30];
char c;
int i;
for(c=65,i=0; c<=90; c++,i++){
str[i] = c;
}
str[i] = 0; //此处为添加的代码，也可以写作 str[i] = '\0';
printf("%s\n", str);
return 0;
}
更加专业的做法是将数组的所有元素都初始化为“零”值，这样才能够从根本上避免问题。再次修改上面的代码：
#include
int main(){
char str[30] = {0}; //将所有元素都初始化为 0，或者说 '\0'
char c;
int i;
for(c=65,i=0; c<=90; c++,i++){
str[i] = c;
}
printf("%s\n", str);
return 0;
}
字符串长度
所谓字符串长度，就是字符串包含了多少个字符（不包括最后的结束符'\0'）。例如"abc"的长度是 3，而不是 4。
在C语言中，我们使用string.h头文件中的 strlen() 函数来求字符串的长度，它的用法为：
length strlen(strname);
strname 是字符串的名字，或者字符数组的名字；length 是使用 strlen() 后得到的字符串长度，是一个整数。
#include
#include //记得引入该头文件
int main(){
char str[] = "http://c.biancheng.net/c/";
long len = strlen(str);
printf("The lenth of the string is %ld.\n", len);
return 0;
}
/*
The lenth of the string is 25.
*/
字符串的输入和输出
字符串的输出
在C语言中，有两个函数可以让用户从键盘上输入字符串，它们分别是：
-
scanf()：通过格式控制符
%s输入字符串。除了字符串，scanf() 还能输入其他类型的数据。 -
gets()：直接输入字符串，并且只能输入字符串。
在C语言中，有两个函数可以在控制台（显示器）上输出字符串，它们分别是：
-
puts()：输出字符串并自动换行，该函数只能输出字符串。
-
printf()：通过格式控制符
%s输出字符串，不能自动换行。除了字符串，printf() 还能输出其他类型的数据。
#include
int main(){
char str[] = "http://c.biancheng.net";
printf("%s\n", str); //通过字符串名字输出
printf("%s\n", "http://c.biancheng.net"); //直接输出
puts(str); //通过字符串名字输出
puts("http://c.biancheng.net"); //直接输出
return 0;
}
/*
http://c.biancheng.net
http://c.biancheng.net
http://c.biancheng.net
http://c.biancheng.net
*/
注意，输出字符串时只需要给出名字，不能带后边的[ ]，例如，下面的两种写法都是错误的：
printf("%s\n", str[]);
puts(str[10]);
字符串的输入
在C语言中，有两个函数可以让用户从键盘上输入字符串，它们分别是：
-
scanf()：通过格式控制符
%s输入字符串。除了字符串，scanf() 还能输入其他类型的数据。 -
gets()：直接输入字符串，并且只能输入字符串。
但是，scanf() 和 gets() 是有区别的：
-
scanf() 读取字符串时以空格为分隔，遇到空格就认为当前字符串结束了，所以无法读取含有空格的字符串。
-
gets() 认为空格也是字符串的一部分，只有遇到回车键时才认为字符串输入结束，所以，不管输入了多少个空格，只要不按下回车键，对 gets() 来说就是一个完整的字符串。换句话说，gets() 用来读取一整行字符串。
#include
int main(){
char str1[30] = {0};
char str2[30] = {0};
char str3[30] = {0};
//gets() 用法
printf("Input a string: ");
gets(str1);
//scanf() 用法
printf("Input a string: ");
scanf("%s", str2);
scanf("%s", str3);
printf("\nstr1: %s\n", str1);
printf("str2: %s\n", str2);
printf("str3: %s\n", str3);
return 0;
}
/*
Input a string: C C++ Java Python↙
Input a string: PHP JavaScript↙
str1: C C++ Java Python
str2: PHP
str3: JavaScript
*/
第一次输入的字符串被 gets() 全部读取，并存入 str1 中。第二次输入的字符串，前半部分被第一个 scanf() 读取并存入 str2 中，后半部分被第二个 scanf() 读取并存入 str3 中。
scanf() 在读取数据时需要的是数据的地址，这一点是恒定不变的，所以对于 int、char、float 等类型的变量都要在前边添加&以获取它们的地址。但是字符串名字或者数组名字在使用的过程中一般都会转换为地址，所以再添加&就是多此一举，甚至会导致错误了。
目前而言，int、char、float 等类型的变量用于 scanf() 时都要在前面添加&，而数组或者字符串用于 scanf() 时不用添加&，它们本身就会转换为地址。
其实 scanf() 也可以读取带空格的字符串
scanf() 的用法还可以更加复杂和灵活，它不但可以完全替代 gets() 读取一整行字符串，而且比 gets() 的功能更加强大。比如，以下功能都是 gets() 不具备的：
-
scanf() 可以控制读取字符的数目；
-
scanf() 可以只读取指定的字符；
-
scanf() 可以不读取某些字符；
-
scanf() 可以把读取到的字符丢弃。
字符串处理函数
C语言提供了丰富的字符串处理函数，可以对字符串进行输入、输出、合并、修改、比较、转换、复制、搜索等操作，使用这些现成的函数可以大大减轻我们的编程负担。
用于输入输出的字符串函数，例如printf、puts、scanf、gets等，使用时要包含头文件stdio.h，而使用其它字符串函数要包含头文件string.h。
字符串连接函数 strcat()
strcat 是 string catenate 的缩写，意思是把两个字符串拼接在一起，语法格式为：
strcat(arrayName1, arrayName2);
arrayName1、arrayName2 为需要拼接的字符串。
strcat() 将把 arrayName2 连接到 arrayName1 后面，并删除原来 arrayName1 最后的结束标志'\0'。这意味着，arrayName1 必须足够长，要能够同时容纳 arrayName1 和 arrayName2，否则会越界（超出范围）。
strcat() 的返回值为 arrayName1 的地址。
#include
#include
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:baidu.com ↙
The URL is baidu.com
*/
字符串复制函数 strcpy()
strcpy 是 string copy 的缩写，意思是字符串复制，也即将字符串从一个地方复制到另外一个地方，语法格式为：
strcpy(arrayName1, arrayName2);
strcpy() 会把 arrayName2 中的字符串拷贝到 arrayName1 中，字符串结束标志'\0'也一同拷贝：
#include
#include
int main(){
char str1[50] = "《C语言变怪兽》";
char str2[50] = "http://c.biancheng.net/cpp/u/jiaocheng/";
strcpy(str1, str2);
printf("str1: %s\n", str1);
return 0;
}
/*
str1: http://c.biancheng.net/cpp/u/jiaocheng/
*/
将 str2 复制到 str1 后，str1 中原来的内容就被覆盖了。
另外，strcpy() 要求 arrayName1 要有足够的长度，否则不能全部装入所拷贝的字符串。
字符串比较函数 strcmp()
strcmp 是 string compare 的缩写，意思是字符串比较，语法格式为：
strcmp(arrayName1, arrayName2);
arrayName1 和 arrayName2 是需要比较的两个字符串。
字符本身没有大小之分，strcmp() 以各个字符对应的 ASCII 码值进行比较。strcmp() 从两个字符串的第 0 个字符开始比较，如果它们相等，就继续比较下一个字符，直到遇见不同的字符，或者到字符串的末尾。
返回值：若 arrayName1 和 arrayName2 相同，则返回0；若 arrayName1 大于 arrayName2，则返回大于 0 的值；若 arrayName1 小于 arrayName2，则返回小于0 的值。
#include
#include
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: 1
a VS c: -1
a VS d: 0
*/
strcmp(a,b)返回值可以理解为"a比b怎么样"，如果a比b大，则返回1，如果a比b小，则返回-1，如果a和b相同（相等），则返回0。
对数组元素进行排序（BubbleSort）
对数组元素进行排序的方法有很多种，比如冒泡排序、归并排序、选择排序、插入排序、快速排序等，其中最经典最需要掌握的是「冒泡排序」。
以从小到大排序为例，冒泡排序的整体思想是这样的：
-
从数组头部开始，不断比较相邻的两个元素的大小，让较大的元素逐渐往后移动（交换两个元素的值），直到数组的末尾。经过第一轮的比较，就可以找到最大的元素，并将它移动到最后一个位置。
-
第一轮结束后，继续第二轮。仍然从数组头部开始比较，让较大的元素逐渐往后移动，直到数组的倒数第二个元素为止。经过第二轮的比较，就可以找到次大的元素，并将它放到倒数第二个位置。
-
以此类推，进行 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，交换）
至此，排序结束。
算法总结及实现
对拥有 n 个元素的数组 R[n] 进行 n-1 轮比较。
第一轮，逐个比较 (R[1], R[2]), (R[2], R[3]), (R[3], R[4]), ……. (R[N-1], R[N])，最大的元素被移动到 R[n] 上。
第二轮，逐个比较 (R[1], R[2]), (R[2], R[3]), (R[3], R[4]), ……. (R[N-2], R[N-1])，次大的元素被移动到 R[n-1] 上。
…
以此类推，直到整个数组从小到大排序。
#include
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 轮的时候，如果剩下的元素已经排序好了，那么就不用再继续比较了，跳出循环即可，这样就减少了比较的次数，提高了执行效率。
未经优化的算法一定会进行 n-1 轮比较，经过优化的算法最多进行 n-1 轮比较，高下立判。
#include
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;
}
我们额外设置了一个变量 isSorted，用它作为标志，值为“真”表示剩下的元素已经排序好了，值为“假”表示剩下的元素还未排序好。
每一轮比较之前，我们预先假设剩下的元素已经排序好了，并将 isSorted 设置为“真”，一旦在比较过程中需要交换元素，就说明假设是错的，剩下的元素没有排序好，于是将 isSorted 的值更改为“假”。
每一轮循环结束后，通过检测 isSorted 的值就知道剩下的元素是否排序好。
总结
数组（Array）是一系列相同类型的数据的集合，可以是一维的、二维的、多维的；最常用的是一维数组和二维数组，多维数组较少用到。
对数组的总结
- 数组的定义格式为：
type arrayName[length]
type 为数据类型，arrayName 为数组名，length 为数组长度。 需要注意的是：
-
数组长度 length 最好是常量表达式，例如 10、204 等，这样在所有编译器下都能运行通过；如果 length 中包含了变量，例如 n、4m 等，在某些编译器下就会报错。
-
数组是一个整体，它的内存是连续的；也就是说，数组元素之间是相互挨着的，彼此之间没有一点点缝隙。
-
一般情况下，数组名会转换为数组的地址，需要使用地址的地方，直接使用数组名即可。
数组的地址即数组中第0个元素的地址。即arr==&arr[0]的结果为1。
- 访问数组元素的格式为：
arrayName[index]
index 为数组下标。注意 index 的值必须大于等于零，并且小于数组长度，否则会发生数组越界，出现意想不到的错误。
- 可以对数组中的单个元素赋值，也可以整体赋值，例如：
// 对单个元素赋值
int a[3];
a[0] = 3;
a[1] = 100;
a[2] = 34;
// 整体赋值（不指明数组长度）
float b[] = { 23.3, 100.00, 10, 0.34 };
// 整体赋值（指明数组长度）
int m[10] = { 100, 30, 234 };
// 字符数组赋值
char str1[] = "http://c.biancheng.net";
// 将数组所有元素都初始化为0
int arr[10] = {0};
char str2[20] = {0};
- 字符串是本章的重点内容，大家要特别注意字符串结束标志
'\0'，各种字符串处理函数在定位字符串时都把'\0'作为结尾，没有'\0'就到达不了字符串的结尾。