第 11 章数组
11.1 为什么需要数组
一个养鸡场有 6 只鸡,它们的体重分别是 3kg,5kg,1kg, 3.4kg,2kg,50kg 。请问这六只鸡的总体重是多少?平均体重是多少? 请你编一个程序。
传统方案
-
定义 6 个 double 变量
-
统计他们和,并求出平均值
-
传统的方案,不灵活,不能够完成数量大的需求
-
引出我们讲解 数组
11.2 数组介绍
数组可以存放多个同一类型数据。数组也是一种数据类型,是构造类型。传递是以引用的方式传递(即传递的是地址)
11.3 数组快速入门
#include <stdio.h>
int main() {
/*
一个养鸡场有 6 只鸡,它们的体重分别是 3kg,5kg,1kg, 3.4kg,2kg,50kg 。请问这六只鸡的总体重是多少?平
均体重是多少? 请你编一个程序。
*/
//1 定义数组
double hens[6];
double totalWeight = 0.0;
double avgWeight = 0.0;
int i, arrLen;
//2. 初始化数组的每个元素
//[下标]
hens[0] = 3; //第一个元素hens[1] = 5; //第 2 个元素
hens[2] = 1;
hens[3] = 3.4;
hens[4] = 2;
hens[5] = 50;
//3. 遍历数组
//如何得到数组大小
// sizeof(hens) 数组的总的大小
// 6 * 8 = 48
// sizeof(double) 返回 一个 double 占用的字节数
//printf("sizeof(hens)=%d", sizeof(hens));
arrLen = sizeof(hens) / sizeof(double);
for(i = 0; i < arrLen; i++) {
totalWeight += hens[i]; // 累计每只鸡体重
}
avgWeight = totalWeight / 6;
printf("总体重 totalWeight=%.2f 平均体重 avgWeight=%.2f", totalWeight, avgWeight); getchar();
}
比如,我们可以用数组来解决上一个问题
11.4 数组定义和内存布局
11.4.1 数组的定义
数据类型 数组名 [数组大小];
int a [5]; // a 数组名,类型 int , [5] 大小, 即 a 数组最多存放 5 个 int 数据赋初值 a[0] = 1; a[1] = 30; …
说明:
-
数组名 就代表 该数组的首地址 ,即 a[0]地址
-
数组的各个元素是 连续分布的, 假如 a[0] 地址 0x1122 a[1] 地址= a[0]的地址+int 字节数(4) = 0x1122 + 4 =
0x1126,后面 a[2] 地址 = a[1]地址 + int 字节数(4) = 0x1126 + 4 = 0x112A, 依次类推
11.4.3 访问数组元素
数组名[下标] 比如:你要使用 a 数组的第三个元素 a[2], 下标是从 0 开始计算
11.4.4 快速入门案例
从终端循环输入 5 个成绩,保存到 double 数组,并输出
代码:
#include <stdio.h>
int main() {
/*
从终端循环输入 5 个成绩,保存到 double 数组,并输出
*/
//定义数组和初始化数组的方式
int arr2[3] = {10, 20, 80};
//如果在定义时,直接就指定值,可以省略数组大小
int arr3[] = {110, 220, 800};
//定义一个数组
double arr[5];
int arrLen = sizeof(arr) / sizeof(double);
int i;
for(i = 0; i < arrLen; i++) {
printf("\n 请输入一个小数");
scanf("%lf", &arr[i]);
}
//输出整个数组printf("\n======================\n");
for(i = 0; i < arrLen; i++) {
printf("arr[%d]=%.2f ", i, arr[i]);
}
getchar(); //过滤回车getchar();
}
输出结果:
请输入一个小数1.1
请输入一个小数1.2
请输入一个小数1.3
请输入一个小数1.4
请输入一个小数1.5
arr[0]=1.10 arr[1]=1.20 arr[2]=1.30 arr[3]=1.40 arr[4]=1.50
--------------------------------
Process exited after 22.94 seconds with return value 0
请按任意键继续. . .
11.4.5 3 种初始化数组的方式:
int arr[10]; //定义长度为10的int类型数组
//定义并初始化数组
int a[5]={1,2,3,4,5};
等价于:a[0]=1; a[1]=2; a[2]=3; a[3]=4; a[4]=5;
//只给一部分元素赋值:
如 int a[5]={6,2,3};
等价于: a[0]=6; a[1]=2;a[2]=3; a[3]=0; a[4]=0;
如 int a[3]={6,2,3,5,1};
//数组元素值全部为0
int a[5]={0,0,0,0,0}; 或int a[5]={0};
//对整个数组元素赋初值时,可以不指定长度。
//编译系统根据初值个数确定数组大小
int arr[] = {1,2,3,4,5,6,7}; //定义并初始化数组
11.5 数组使用注意事项和细节
-
数组是多个相同类型数据的组合,一个数组一旦声明/定义了,其长度是固定的, 不能动态变化。
-
数组创建后,如果没有赋值,则遵守如下规则全局数组默认值 0
非全局数组初值是机器垃圾值(即:原来系统分配给这块空间的值)
-
使用数组的步骤 1. 定义数组 2 给数组各个元素赋值 3 使用数组, 也可以一步到位
-
数组的下标是从 0 开始的, 不是从 1 开始。
-
数组下标必须在指定范围内使用,编译通过,在运行时会因为数组越界而异常中断: 比如 int arr [5] 有效下标为 0-4
-
C 的数组属构造类型, 是引用传递(传递的是地址),因此当把一个数组传递给一个函数时/或者变量,函数/变量操作数组会影响到原数组. [内存图!!!]
#include <stdio.h>
void f1(int arr[]) {
printf("f1 函数中 的 arr 的地址 = %p\n", arr);
arr[0] = arr[0] + 1;
}
int main() {
int arr[3] = {3,4,5}; int i;
printf("main 函数中 的 arr 的地址 = %p\n", arr);
//数组默认是以 地址传递(传递指针)
f1(arr);
//遍历 main 函数中的 arr
for(i = 0; i < 3; i++) {
printf("arr[%d]=%d \n", i , arr[i]); // 4,4,5
}
getchar();
}
内存图:
11.6 数组应用案例
- 创建一个 char 类型的 26 个元素的数组,分别 放置’A’-'Z‘。使用 for 循环访问所有元素并打印出来。提示:字符数据运算 ‘A’+1 -> ‘B’
#include <stdio.h>
int main(){
/*
创建一个 char 类型的 26 个元素的数组,分别 放置'A'-'Z'。
使用 for 循环访问所有元素并打印出来。提示:字符数据运算 'A'+1 -> 'B'
*/
char arr[26]; int i;
for (i =0; i < 26; i++) {
arr[i] = 'A' + i;
}
//输出
for(i = 0; i < 26; i++ ){
printf("%c ", arr[i]);
}
getchar();
}
- 请求出一个数组的最大值,并得到对应的下标。
#include <stdio.h>
int main(){
/*
请求出一个数组的最大值,并得到对应的下标分析
1. 定义数组 大小 5
2. 假定 max = arr[0] 就是最大值,然后我们依次和数组后面的数进行比较,如果发现比 有比 max
更大数,就相应的变化(把更大数赋给 max),当我们遍历完整个数组,max 就是最大数
*/
int arr[] = {0,-1,89, 99, 4,0,23,876, 9876,3,4,6};
int arrLen = sizeof(arr) / sizeof(int); int max = arr[0];
int maxIndex = 0; int i ;
for(i = 1; i < arrLen; i++) {
//如果发现比 有比 max 更大数,就相应的变化(把更大数赋给 max)
if( arr[i] > max) {
max = arr[i]; maxIndex = i;
}
}
printf("max=%d maxIndex=%d", max, maxIndex);
getchar();
}
一维数组程序举例
例:读10个整数存入数组,找出其中的最大值和最小值
步骤
1. 输入:使用for循环输入10个整数
2. 处理:
(a) 先令max=min=x[0]
(b) 依次用x[i]和max,min比较(循环)
若max<x[i],令max=x[i]
若min>x[i],令min=x[i]
3. **输出:**max和min
#include <stdio.h>
#define SIZE 10
int main()
{
int x[SIZE],i,max,min;
printf("Enter 10 integers:\n");
for(i=0;i<SIZE;i++){
printf("%d:",i+1);
scanf("%d",&x[i]);
}
max=min=x[0];
for(i=1;i<SIZE;i++){
if(max<x[i]) max=x[i];
if(min>x[i]) min=x[i];
}
printf("Maximum value is %d\n",max);
printf("Minimum value is %d\n",min);
}
5:数组.顺序集合
假如我们定义了一个长度为 10 的数据,操作系统就会为其分配连续的十个内存地址。
这些地址用来存放地址,每一个地址所占的字节是数组的数据类型所决定的。
如int类型的每一个地址占据着4个字节,double类型的8个。
代码:
#include<stdio.h>
int main(){
int arr[10];
for(int i = 0; i < 10; i++){
printf("&arr[%d] = %d\n",i,&arr[i]);
}
}
输出结果:
&arr[0] = 6487536
&arr[1] = 6487540
&arr[2] = 6487544
&arr[3] = 6487548
&arr[4] = 6487552
&arr[5] = 6487556
&arr[6] = 6487560
&arr[7] = 6487564
&arr[8] = 6487568
&arr[9] = 6487572
--------------------------------
Process exited after 0.01689 seconds with return value 0
请按任意键继续. . .
可以注意到各个元素之间的地址相差了4,为啥是4而不是别的呢?这是因为一个我一开始定义的数据类型是int类型的。
这里补充下内存地址的理解:
1:内存地址只是一个编号,代表一个内存空间。
2:内存地址也是内存当中存储数据的一个标识,并不是数据本身,通过内存地址可以找到内存当中存储的数据。<相当于通过你身份证上的地址信息,可以找到你的家乡一样.>
3:你也可以把计算机内存想象成一条长街上一间间房子,每间房子上面都有且只有一个唯一的编号,房子可以存放数据。
如这里的首元素的内存编号是 6487536,第二个元素的内存编号是 6487540,
这里也需要知道一点,这里的编号,只是该数据存放的首地址,只需要知道首地址就可以获取整个地址的值。
6、数组的越界
这里讲的数组长度存在一个上界,一旦超过了这个界限会如何?
前面讲述到了,一旦数组定义完毕,系统就会为其分配它长度大小的空间地址。
而一旦超过了这个大小,就会发生一些未知的错误,也就是所谓的越界
这里用一个例子来说明下越界后数组内部的值的情况:
代码:
#include<stdio.h>
int main(){
int arr[5] = {1,2,3,4,5};//定义一个长度为5 的数组,并赋初始值
for(int i = 0; i < 10; i++) {
printf("arr[%d] = %d\n",i,arr[i]);
}
}
输出结果:
arr[0] = 1
arr[1] = 2
arr[2] = 3
arr[3] = 4
arr[4] = 5
arr[5] = 0
arr[6] = 1
arr[7] = 7
arr[8] = 7410592
arr[9] = 0
--------------------------------
Process exited after 0.01397 seconds with return value 0
请按任意键继续. . .
由运行结果可以知道,当数组的下标超过了上界后,其后面的值都是不确定的。
11.7 字符数组与字符串
11.7.1 字符数组基本介绍
用来存放字符的数组称为字符数组, 看几个案例
-
char a[10]; //一维字符数组, 长度为 10
-
char b[5][10]; //二维字符数组, 后面我们详细介绍二维数组
-
char c[20]={‘c’, ’ ', ‘p’, ‘r’, ‘o’, ‘g’, ‘r’, ‘a’,‘m’}; // 给部分数组元素赋值
字符数组实际上是一系列字符的集合,也就是字符串(String)。在 C 语言中,没有专门的字符串变量,没有
string 类型,通常就用一个字符数组来存放一个字符串
11.7.2 字符串注意事项
-
在 C 语言中,字符串实际上是使用 null 字符 ('\0') 终止的一维字符数组。因此,一个以 null 结尾的字符串, 包含了组成字符串的字符。
-
'\0'是 ASCII 码表中的第 0 个字符,用 NUL 表示,称为空字符。该字符既不能显示,也不是控制字符,输出该字符不会有任何效果,它在 C 语言中仅作为字符串的结束标志。
3) 字符数组(字符串)在内存中的布局分析 [案例]
- 思考 char str[3] = {‘a’,‘b’,‘c’} 输出什么? 为什么?
**结论:**如果在给某个字符数组赋值时,(1)赋给的元素的个数小于该数组的长度,则会自动在后面加 ‘\0’, 表示字符串结束,(2)赋给的元素的个数等于该数组的长度,则不会自动添加 ‘\0’
char str2[] = {‘t’,‘m’,‘o’} 输出什么? 输出的是 tmo 乱码
- 案例演示
#include <stdio.h>
int main() {
//c 是一个一维字符数组,给部分元素赋值
char c[7]={'t','o','m'};
char str[5] = {'a','b','c','\0','d'};
char str2[] = {'j','a','c','k'}; // 这个后面系统也不会自动添加 '\0'
//输出 c , 系统会这样处理
//1. 从第一个字符开始输出,直到遇到 \0 , 表示该字符串结束
printf("\nc=%s", c);
printf("\nstr=%s", str); // abc?
printf("\nstr2=%s", str2); // jack 乱码
getchar();
}
11.7.3 字符串的访问和遍历
因为字符串的本质就是字符数组,因此可以按照数组的方式遍历和访问某个元素即可, 案例如下
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int main() {
char greeting[] = "Hello";
int i;
int len = strlen(greeting); // len = 5
printf("greeting=%s\n", greeting);
printf("len=%d\n", len); //5
printf("字符串第 3 个字符是=%c\n", greeting[2]); //l
for(i = 0; i < len; i++) {//遍历
printf("%c ", greeting[i]); //H e l l o
}
printf("\n");
system("pause");
}
Ø 对应的内存分析
11.8 字符串的表示形式
11.8.1 用字符数组存放一个字符串:
用字符数组存放一个字符串,
-
char str[]=“hello tom”;
-
char str2[] = {‘h’, ‘e’};
11.8.2 用字符指针指向一个字符串
比如: char * pStr=" hello tom";
-
C 语言对字符串常量" hello tom"是按字符数组处理的,在内存中开辟了一个字符数组用来存放字符串常量,程序在定义字符串指针变量 str 时只是把字符串首地址(即存放字符串的字符数组的首地址)赋给 pStr
-
printf("%s\n",str); 可以输出 str 指向的字符串
-
对应的内存布局图(!!)
11.8.3 使用字符指针变量和字符数组两种方法表示字符串的讨论
- 字符数组由若干个元素组成,每个元素放一个字符;而字符指针变量中存放的是地址(字符串/字符数组的首地
址),绝不是将字符串放到字符指针变量中(是字符串首地址) [图]
- 对字符数组只能对各个元素赋值,不能用以下方法对字符数组赋值
char str[14];
str=" hello tom"; //错误
str[0] = 'i'; //ok
- 对字符指针变量,采用下面方法赋值, 是可以的
char* a="yes";
a=" hello tom";
-
分析上面的结论
-
如果定义了一个字符数组,那么它有确定的内存地址(即字符数组名是一个常量);而定义一个字符指针变量时, 它并未指向某个确定的字符数据,并且可以多次赋值 [代码+图解]
11.9 字符串相关函数
11.9.1 常用字符串函数一览
字符串函数应用案例
#include <stdio.h>
#include <string.h>
int main() {
char str1[12] = "Hello";
char str2[12] = "World";
char str3[12];
int len ;
/* 复制 str1 到 str3 */
strcpy(str3, str1); // str3 内 容 "Hello"
printf("strcpy( str3, str1) : %s\n", str3 ); //"Hello"
/* 连接 str1 和 str2 */
strcat( str1, str2);
printf("strcat( str1, str2): %s\n", str1 ); //"HelloWorld"
/* 连接后,str1 的总长度 */
len = strlen(str1);//
printf("strlen(str1) : %d\n", len );//10
getchar();
}
11.10 字符串(字符数组)使用注意事项和细节
-
程序中往往依靠检测 '\0' 的位置来判定字符串是否结束,而不是根据数组的长度来决定字符串长度。因此,字符串长度不会统计 '\0', 字符数组长度会统计 [案例]
-
在定义字符数组时应估计实际字符串长度,保证数组长度始终大于字符串实际长度, 否则,在输出字符数组时可能出现未知字符.
-
系统对字符串常量也自动加一个'\0'作为结束符。例如"C Program”共有 9 个字符,但在内存中占 10 个字节, 最后一个字节'\0'是系统自动加上的。(通过 sizeof()函数可验证)
-
定义字符数组时,如果 给的字符个数 比 数组的长度小,则系统会默认将剩余的元素空间,全部设置为 '\0', 比如 char str[6] = "ab" , str 内存布局就是
[a][b][\0][\0][\0][\0]
- 字符数组定义和初始化的方式比较多,比如
#include <stdio.h>
int main() {
char str1[ ]={"I am happy"}; // 默认后面加 '\0'
char str2[ ]="I am happy"; // 省略{}号 ,默认后面加 '\0'
char str3[ ]={'I',' ','a','m',' ','h','a','p','p','y'}; // 字符数组后面不会加 '\0', 可能有乱码
char str4[5]={'C','h','i','n','a'}; //字符数组后面不会加 '\0', 可能有乱码
char * pStr = "hello";//ok
printf("\n str1=%s", str1);
printf("\n str2=%s", str2);//ok
printf("\n str3=%s", str3);//
printf("\n str4=%s", str4);//
printf("\n");
printf("* pStr=%s",pStr);
getchar();
}
12.1 排序算法的介绍
排序也称排序算法(Sort Algorithm),排序是将一组数据,依指定的顺序进行排列的过程。
排序的分类:
- 内部排序:
指将需要处理的所有数据都加载到内部存储器(内存)中进行排序。
- 外部排序法:
数据量过大,无法全部加载到内存中,需要借助外部存储进行排序。
12.2 冒泡排序
12.2.1 基本介绍
冒泡排序(Bubble Sorting)的基本思想是:通过对待排序序列从前向后(从下标较小的元素开始),依次比较相邻元素的值,若发现逆序则交换,使值较大
的元素逐渐从前移向后部,就象水底下的气泡一样逐渐向上冒。
因为排序的过程中,各元素不断接近自己的位置,如果一趟比较下来没有进行过交换,就说明序列有序,因此要在排序过程中设置 一个标志 flag 判断元素是否进行过交换。从而减少不必要的比较。
理解:数组中两个数进行比较,较大数放在后面
优化:
因为排序的过程中,各元素不断接近自己的位置,如果一趟比较下来没有进行过交换,就说明序列有序,因此要在排序中设置一个标志flag判断元素是否进行过交换。从而减少不必要的比较。
原始数组:3,9,-1,10,20
第一趟排序
[1] 3,9,-1,10,20 //如果相邻的元素逆序就交换
[2] 3,-1,9,10,20
[3] 3,-1,9,10,20
[4] 3,-1,9,10,20
第二趟排序
[1] -1,3,9,10,20
[2] -1,3,9,10,20
[3] -1,3,9,10,20
第三趟排序
[1] -1,3,9,10,20
[2] -1,3,9,10,20
第四趟排序
[1] -1,3,9,10,20
小结冒泡排序规则:
(1)一共进行数组的大小-1次大的循环
(2)每一趟排序的次数在逐渐的减少
(3)如果我们发现在某趟排序中,没有发生一次交换,就可以提前结束冒泡排序。
12.2.3 分析冒泡的过程+代码
#include<stdio.h>
int main(){
int arr[10];
for(int i = 0; i < 10; i++){
scanf("%d",&arr[i]);
}
printf("排序之前:");
for(int i = 0; i < 10; i++){
printf("%d ",arr[i]);
}
printf("\n");
for(int i = 0; i < 10; i++){
for(int j = 0; j < 10-1;j++){
if(arr[j] > arr[j+1]){//如果前面的值大于后面的值,就让这两个数交换在数组中的位置
int temp = arr[j];//temp是临时变量
arr[j] = arr[j+1];
arr[j+1] = arr[j];
}
}
}
printf("排序之后:");
for(int i = 0; i < 10; i++){
printf("%d ",arr[i]);
}
}
12.3 查找
12.3.1 介绍:
在 C 中,我们常用的查找有两种:
-
顺序查找
-
二分查找
12.3.2 案例演示:
- 有一个数列:{23, 1, 34,89, 101}
猜数游戏:从键盘中任意输入一个数,判断数列中是否包含该数【顺序查找】 要求: 如果找到了,就提示找到, 并给出下标值, 找不到提示 没有。
#include <stdio.h>
int main() {
//分析思路
//1. 安装数组进行遍历,一个一个的比较,如果相等,则找到
int arr[] = {23, 1, 34,89,101};
int arrLen = sizeof(arr) / sizeof(int);
int value;
scanf("%d",&value);
int index = -1;
for(int i = 0; i < arrLen; i++) {
if(arr[i] == value) {
index = i;
}
}
if (index != -1) { //找到
printf("找到 下标为 %d", index);
} else {
printf("没有找到");
}
getchar();
}
- 请对一个有序数组进行二分查找 {1,8, 10, 89, 1000, 1234} ,输入一个数看看该数组是否存在此数,并且求出下标,如果没有就提示"没有这个数"。二分查找的前提是,该数组是一个有序数组
#include <stdio.h>
//二分查找
int binarySearch(int arr[], int leftIndex, int rightIndex, int findVal) {
//先找到数组中间这个数 midVal
int midIndex = (leftIndex + rightIndex) / 2;
int midVal = arr[midIndex];
//如果 leftIndex > rightIndex, 说明这个数组都比较过,但是没有找到
if( leftIndex > rightIndex) {
return -1;//!!!!
}
//如果 midVal > findVal 说明, 应该在 midVal 的左边查找
if(midVal > findVal) {
binarySearch(arr, leftIndex, midIndex-1, findVal);//!!!
} else if(midVal < findVal){//如果 midVal < findVal 说明, 应该在 midVal 的右边查找
binarySearch(arr, midIndex+1, rightIndex, findVal);//!!!
} else {
return midIndex; //返回该数的下标
}
}
int main() {
//思路分析
// 比如我们要查找的数是 findVal
//1. 先找到数组中间这个数 midVal,和 findVal 比较
//2. 如果 midVal > findVal 说明, 应该在 midVal 的左边查找
//3. 如果 midVal < findVal 说明, 应该在 midVal 的右边查找
//4. 如果 midVal == findVal, 说明找到
//5. 这里还有一个问题,没有考虑找不到情况
int arr[] = {1,8, 10, 89, 1000, 1234};
int arrLen = sizeof(arr) / sizeof(int);
int value;
scanf("%d",&value);
int index = binarySearch(arr, 0, arrLen-1, value);
if(index != -1) {
printf("找到 index = %d", index);
} else {
printf("没有找到");
}
getchar();
}
12.4 多维数组-二维数组
多维数组我们介绍二维数组
12.5 二维数组的应用场景
比如我们开发一个五子棋游戏,棋盘就是需要二维数组来表示。
12.6 二维数组的使用
12.6.1 快速入门案例:
请用二维数组输出如下图形
0 0 0 0 0 0
0 0 1 0 0 0
0 2 0 3 0 0
0 0 0 0 0 0
12.6.2 使用方式 1: 先定义在初始化
语法: 类型 数组名[size][size];
比如: int a[2][3];
12.6.3 使用演示
二维数组在内存的存在形式,各个元素的地址是连续分布的,即在前一个元素基础上+4
#include <stdio.h>
int main(){
//a[4][6] : 表示一个 4 行 6 列的二维数组
int a[4][6]; // 没有初始化,则是分配的内存垃圾值
int i, j;
//全部初始化 0
for(i = 0; i < 4; i++) { //先遍历行
for(j = 0; j < 6; j++) {//遍历列
a[i][j] = 0;
}
}
a[1][2] = 1;
a[2][1] = 2;
a[2][3] = 3;
//输出二维数组
for(i = 0; i < 4; i++) {
for(j = 0; j < 6; j++) {
printf("%d ", a[i][j]);
}
printf("\n");
}
看看二维数组的内存布局
printf("\n 二维数组 a 的首地址=%p", a);
printf("\n 二维数组 a[0]的地址=%p", a[0]);
printf("\n 二维数组 a[0][0]的地址=%p", &a[0][0]);
printf("\n 二维数组 a[0][1]的地址=%p", &a[0][1]);
//将二维数组的各个元素得地址输出printf("\n");
// for(i = 0; i < 4; i++) {
// printf("a[%d]的地址=%p ", i, a[i]);
// for(j=0; j < 6; j++) {
// printf("a[%d][%d]的地址=%p ", i, j , &a[i][j]);
// }
// printf("\n");
// }
getchar();
}
二维数组布局图:
12.6.4 使用方式 2: 直接初始化
-
定义 类型 数组名[大小][大小] = {{值 1,值 2…},{值 1,值 2…},{值 1,值 2…}};
-
或者 类型 数组名[大小][大小] = { 值 1,值 2,值 3,值 4,值 5,值 6 …};
int a[4][6] = {
{0,0,0,0,0,0},
{0,0,1,0,0,0},
{0,2,0,3,0,0},
{0,0,0,0,0,0}
};
int a[4][6] = {0,0,0,0,0,0,0,0,1,0,0,0,0,2,0,3,0,0,0,0,0,0,0,0};
12.7 二维数组的应用案例
12.7.1 案例 1
int arr[3][2]={{4,6},{1,4},{-2,8}};
遍历该二维数组,并得到和?
#include <stdio.h>
int main(){
int map[3][3] = {
{0,0,1},
{1,1,1},
{1,1,3}
};
//遍历
//先得到行
//1. sizeof(map) 得到这个 map 数组的大小 9 * 4 = 36
//2. sizeof(map[0]) 得到 map 中,第一行有多大 3 * 4 = 12
int rows = sizeof(map) / sizeof(map[0]); // 3
/*printf("rows=%d", rows);*/
//得到列
int cols = sizeof(map[0]) / sizeof(int); // 12 / 4 = 3
int i,j, sum=0;
for(i = 0; i < rows; i++) {
for(j = 0; j < cols; j++) {
printf("%d ",map[i][j]);
sum += map[i][j];//累计到 sum
}
printf("\n");
}
printf("\nsum=%d", sum);
getchar();
}
12.7.4 定义二维数组,用于保存三个班,每个班五名同学成绩,并求出每个班级平均分、以及所有班级平均分
#include <stdio.h>
int main(){
/*
定义二维数组,用于保存三个班,
每个班五名同学成绩,并求出每个班级平均分、以及所有班级平均分分析
1. 创建一个 scores[3][5]
2. 遍历,给赋值
3. 再次遍历,统计总分和平均分
4. 输出
*/
double score[3][5]; //
int rows = sizeof(score) / sizeof(score[0]), cols = sizeof(score[0])/sizeof(double), i, j; //
//classTotalScore 各个班级总成绩 totalScore 所有学生成绩
double totalScore = 0.0, classTotalScore = 0.0;
for (i = 0; i < rows; i++ ) {
for (j = 0; j < cols ; j++ ) {
score[i][j] = 0.0; //初始化
}
}
//遍历,给每个学生输入成绩
for (i = 0; i < rows; i++ ) {
for (j = 0; j < cols ; j++ ) {
printf("请输入第 %d 个班的 第 %d 个 学生的成绩:", i + 1, j + 1);
scanf("%lf", &score[i][j]);
}
}
getchar();
//显示下成绩情况
for (i = 0; i < rows; i++ ) {
for (j = 0; j < cols ; j++ ) {
printf("%.2f ",score[i][j]);
}
printf("\n");
}
//统计各个班的总成绩,和所有学生的总成绩
for (i = 0; i < rows; i++ ) {
classTotalScore = 0.0; // 每次清 0
for (j = 0; j < cols ; j++ ) {
classTotalScore += score[i][j]; //累计每个班的总成绩
}
printf("\n 第 %d 个班的平均成绩是 %.2f" , i+1, classTotalScore/cols );
totalScore += classTotalScore; //将该班级的总分,累计到 totalScore
}
printf("\n 所有学生总成绩是 %.2f 平均成绩 %.2f" ,totalScore, totalScore/(rows * cols));
getchar();
}
12.8 二维数组使用细节和注意事项
- 可以只对部分元素赋值,未赋值的元素自动取“零”值【案例】
#include <stdio.h>
int main(){
int a[4][5] = {{1}, {2}, {3},{1}};
int i,j;
for (i = 0; i < 4; i++ ) {
for (j = 0; j < 5 ; j++ ) {
printf("%d ",a[i][j]);
}
printf("\n");
}
getchar();
}
- 如果对全部元素赋值,那么第一维的长度可以不给出。比如:
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};
- 二维数组可以看作是由一维数组嵌套而成的;如果一个数组的每个元素又是一个数组,那么它就是二维数组。
二维数组 a[3][4]可看成三个一维数组,它们的数组名分别为 a[0]、a[1]、a[2]。
这三个一维数组都有 4 个元素,如,一维数组 a[0] 的元素为 a[0][0]、a[0][1]、a[0][2]、a[0][3]