C语言数组

最新推荐文章于 2023-05-06 09:02:08 发布

qykhhr

最新推荐文章于 2023-05-06 09:02:08 发布

阅读量938

点赞数

文章标签： c语言

本文链接：https://blog.csdn.net/qq_46070108/article/details/108996504

版权

笔记专栏收录该内容

36 篇文章 0 订阅

订阅专栏

第 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]

qykhhr

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
C语言数组

第 11 章数组11.1 为什么需要数组一个养鸡场有 6 只鸡，它们的体重分别是 3kg,5kg,1kg, 3.4kg,2kg,50kg 。请问这六只鸡的总体重是多少?平均体重是多少? 请你编一个程序。传统方案定义 6 个 double 变量统计他们和，并求出平均值传统的方案，不灵活，不能够完成数量大的需求引出我们讲解数组11.2 数组介绍数组可以存放多个同一类型数据。数组也是一种数据类型，是构造类型。传递是以引用的方式传递(即传递的是地址)11.
复制链接

扫一扫