零基础入门学习C语言007讲：数组（2）

╰+攻爆jí腚メ 2022-04-24 19:36 357阅读 0赞

# 二维数组的定义和引用 #

### 二维数组的定义 ###

二维数组定义的一般形式为

类型说明符  数组名  \[常量表达式\]  \[常量表达式\];

例如：定义a为3\*4（3行4列）的数组，b为5\*10（5行10列）的数组。如下：

float a \[3\]\[4\],  b \[5\]\[10\];

不能写成 float a \[3,4\], b \[5,10\];

例如：

int a\[3\]\[4\];

说明了一个三行四列的数组，数组名为a，其下标变量的类型为整型。该数组的下标变量共有3\*4个，即:

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

我们可以把二维数组看做是一种特殊的一维数组：它的元素又是一个一维数组。

例如，可以把a看作是一个一维数组，它有3个元素：a\[0\]、a\[1\]、a\[2\]，每个元素又是一个包含4个元素的一维数组。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTU2MzE4_size_16_color_FFFFFF_t_70][]

二维数组在概念上是二维的，但是，实际的硬件存储器却是连续编址的，也就是说存储器单元是按一维线性排列的。

如何在一维存储器中存放二维数组，可有两种方式：一种是按行排列，即放完一行之后顺次放入第二行。另一种是按列排列，即放完一列之后再顺次放入第二列。在C语言中，二维数组是按行排列的。

### 衍生：多维数组的定义 ###

有了二维数组的基础，那么多维数组如何定义呢？

定义三维数组：float a\[2\]\[3\]\[4\];

多维数组元素在内存中的排列顺序：第一维的下标变化最慢，最右边的下标变化最快。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTU2MzE4_size_16_color_FFFFFF_t_70 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\}\};**

![20190429194700554.png][]

也可以对各行中的某一元素赋初值，如**：**

**int a［3］［4］=\{ \{1\}，\{0，6\}，\{0，0，11\}\};**

![20190429194719655.png][]

其实也可以只对某几行元素赋初值。如：

**int a［3］［4］=\{ \{1\}，\{5，6\}\};**

![20190429194732644.png][]

(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\}\};**

![20190429194839608.png][]

例题：如图，一个学习小组有5个人，每个人有三门课的考试成绩。将各个数据保存到二维数组a\[5\]\[3\]中，并求全组分科的平均成绩和总平均成绩。

![20190429194928735.png][]

对数组a\[5\]\[3\]：

1)       按行分段赋值可写为:

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

2)       按行连续赋值可写为:

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

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

#include  <stdio.h>
    void main()
    {
    	int i, j, s = 0, average, 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++)
    			s = s + a[j][i];
    		v[i] = s / 5;
    		s = 0;
    	}
    	average = (v[0] + v[1] + v[2]) / 3;
    	printf("math:%d\nc languag:%d\ndFoxpro:%d\n", v[0], v[1], v[2]);
    	printf("total:%d\n", average);
    }

# **  二维数组程序举例** #

### NO.1 将一个二维数组行和列元素互换，存到另一个二维数组中。 ###

i.e.将数组a\[2\]\[3\]转化为数组b\[3\]\[2\]

![20190429195349204.png][]

#include <stdio.h>
    void main()
    {
    	int  a[2][3] = { { 1, 2, 3 }, { 4, 5, 6 } };
    	int  b[3][2], i, j;
    	printf("array a : \n");
    	for (i = 0; i <= 1; i++)
    	{
    		for (j = 0; j <= 2; j++)
    		{
    			printf("% 5d", a[i][j]);
    			b[j][i] = a[i][j];
    		}
    		printf("\n");
    	}
        printf("array b : \n");
    	for (i = 0; i <= 2; i++)
    	{
    		for (j = 0; j <= 1; j++)
    		{
    			printf("% 5d", b[i][j]);			
    		}
    		printf("\n");
    	}
    }

### NO.2 有一个3×4的矩阵，要求编程序求出其中值最大的那个元素的值，以及其所在的行号和列号。 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTU2MzE4_size_16_color_FFFFFF_t_70 2][]

#include <stdio.h>
    void main()
    {
    	int i, j, row = 0, colum = 0, max;
    	int a[3][4] = { { 1, 2, 3, 4 }, { 9, 8, 7, 6 }, { -10, 10, -5, 2 } };
    	max = a[0][0];
    	for (i = 0; i <= 2; i++)
    	{
    		for (j = 0; j <= 3; j++)
    		{
    			if (a[i][j]>max)
    			{
    				max = a[i][j];    row = i;   colum = j;
    			}
    		}
    	}
    	printf("max = %d，row = %d，colum = %d\n", max, row, colum);
    } /*程序结束*/

### NO.3  从键盘上输入9个整数，(对照九宫格的形式，输入三行，每行输入三个数) 保存在二维数组中，按数组原来位置输出第一行和第一列的所有元素。 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTU2MzE4_size_16_color_FFFFFF_t_70 3][]

#include <stdio.h>
    void main()
    {
    	int a[3][3];
    
    	/*给二维数组动态初始化*/
    
    	for (int i = 0; i < 3; i++)
    	{
    		for (int j = 0; j < 3; j++)
    		{
    			printf("a[%d][%d]=", i, j);			
    			scanf("%d", &a[i][j]);
    		}
    	}
    	for (int i = 0; i < 3; i++)
    	{
    		for (int j = 0; j < 3; j++)
    		{
    			if (i == 1 || j == 1)
    			{
    				printf("%d\t", a[i][j]);
    			}
    			else
    			{
    				printf("\t");
    			}
    			
    		}
    		printf("\n");
    	}
    } /*程序结束*/

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTU2MzE4_size_16_color_FFFFFF_t_70]: /images/20220212/90a7d71c06e34d38bcc44358820d45a7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTU2MzE4_size_16_color_FFFFFF_t_70 1]: /images/20220212/a16c36a6fc6249179dba3b0f181836d3.png
[20190429194700554.png]: /images/20220212/d9bf3b65e3be4f21806df29c5c06ef2b.png
[20190429194719655.png]: /images/20220212/7f18fc425416485096c7a5686d8ed814.png
[20190429194732644.png]: /images/20220212/41c7a255347a41c68b2d2e958750b372.png
[20190429194839608.png]: /images/20220212/1d52dffd39644e06929bb0e031a264ff.png
[20190429194928735.png]: /images/20220212/89184cc26b4249bb93b95492f3e88df9.png
[20190429195349204.png]: /images/20220212/e9c3a271e2eb413da7cf25acdb64932a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTU2MzE4_size_16_color_FFFFFF_t_70 2]: /images/20220212/e1f79255e55b4bad948df95c6b8d72b8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTU2MzE4_size_16_color_FFFFFF_t_70 3]: /images/20220212/ec46941f836340699c1ee847f996d8a3.png