c语言基础语法三——数组_如何生动形象的讲解c语言数组

谢谢某个障智，带教材回去了，把这数组这章的教材内容拍给我了，不能还真不知道怎么写这篇博客，还是高估自己了啊，还是不能根据自己独立把数组说清道明白啊，依然得依靠教材。
进入主题；
1，引入数组；
教室座位大家应该不陌生吧，毕竟都是过来人，都知道座位是几行几列的，还记得有时候老师点人回答问题就是第几行第几列来回答问题吧。

下面数组的介绍会时不时的用教室位子来比喻介绍；
2；官方数组的概念；

数组就存放一组相同数据的集合；
数组名就是这个集合的名字；
数组元素就是这个集合中的元素；
数组下标就是我们用来区分各个元素的编号，
实例介绍；
int a[5]={1,2,3,4,5};
则这个是存放int类型的集合；
a就是数组名也就是集合名；
1,2,3,4,5,就是表示数组的元素
从0到4就是代表下标；注意这就要区分教室座位了，不是从1开始，而是从0开始，记得在编程语言中几乎都是从0开始的，而不是1；
通过下标表示数组元素；
1——用a[0]表示；//a是数组名，加[]里面是下标；
2——a[1]；
3——a[2]；
4——a[3]；
5——a[4]；
当然这里是int类型；也可以定义char类型，double…….等等；
这里是一维的，就是相当于教室里面的一小组，上面那个a[5]就相当于这组有5个位置，
如果是二维，例如a[2][3];

3;数组的分类；
——3.1；看数据类型可以分为int char等基础类型，还可以为指针结构体类型；
int a[4]；a为int类型的数组；
double b[4][4]；b表示double类型的数组；
——3.2；根据存放的顺序位置分，可分为一维，二维…..
int a[4]；a为一维数组；
double b[4][4]；b表示二维数组；
至于什么是int数组，什么是一维二维数组，在上面也已经介绍了。

4；一维数组；
定义的一般表达式；
数据类型 数组名[数值表达式];
例如 int a[5]；———-定义一个数据类型为int型的一维数组，最多存放5个元素；

4.1；对于数组的初始化问题；
初始化就是在定义的时候也给予赋值；并且在之前也有讲过要使用一个变量，那么必须先赋值再使用，否则这个变量将没有意义(垃圾值)，但是数组有一点点小区别，数组是多个变量的集合，只有其中有一部分被初始化了，那么其余的变量也会存在一个默认值进行初始化的，看程序；

#include<stdio.h> 
#define N 10

int main()
{
    int i;
    int a[N];
    int b[N]={3,4};
    printf("未任何元素初始化数组a\t"); 
    for(i = 0; i < N; i++){
        printf("%d ",a[i]); 
    }
    printf("\n有部分元素初始化数组b\t"); 
    for(i = 0; i < N; i++){
        printf("%d ",b[i]); 
    }

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

这就是数组中初始化要注意的问题；
4.2；在数组中的&取地址符的使用；使用与对数组元素的赋值；
&取地址符；
a[i]；表示第i+1个元素的值；
&a[i]；表示第i+1个元素的地址；
scanf（”%d”,&a[i]）；//输入一个值赋值给a[i]；就是将一个值放到第i+1个元素的地址中去，
看程序；

#include<stdio.h>
#define N 5

int main()
{
    int a[N],i;
    printf("输入%d个数组元素的值  ",N); 
    for(i = 0; i < N; i++){
        scanf("%d",&a[i]);
    }
    printf("\n输出数组元素的值"); 
    for(i = 0; i < N; i++){
        printf("%d ",a[i]);
    }

    return 0;
} 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

4.3；数组名的介绍；数组名首先是一个标识符，是这个数组的名字，同时又是一个指针，指向的是这个数组首地址。
既然是指向首地址的指针，因此就有了第二种表示数组元素的方法，使用数组名；
a；代表指向数组首地址的指针。则就是指向a[0]的地址，则与&a[0]等效；
a+i；则表示指向数组的第i+1个元素。则与&a[i]等效；
*；是取值符。与&恰好相反；
a就相当于a[0]，而*（a+i）就表示a[i]；//记得*(a+i)要打括号，优先级问题，如果没打则表示的是a【0】+i的值；
看程序；

#include<stdio.h>
int main()
{
    int a[5],i;
    for(i = 0; i < 5; i++){
        scanf("%d",a+i);//等效于 scanf("%d",a[i]);
    }
    for(i = 0; i < 5; i++){
        printf("%d ",*(a+i));//等效于 printf("%d ",a[i])； 
    }

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

注意我们然而经常使用的是上面那种使用取地址符的而不是数组名的方法；
4.4；一维数组的一些小程序；

1；计算平均数；
/*
    程序目的；先输入n代表有n个数，接下来输入n个数，
            然后输出这n个数的平均数并且原样输出这n个数 
    注意；计算平均数，先累加再除；
            累加时一定要记得将sum进行初始化为0；（累加初始化为0累乘初始化为1）
            进行除法的时候要注意其数据类型，如果都是整形时则要先乘1.0；是除法式子中有实数类型 

*/
#include<stdio.h>
int main()
{
    int i, n;
    double sum, avg;
    double a[100];//定义一个数组，来存放数 
    sum = 0;//计算这些数的和，进行累加，因此要将其初始化为0；
    //将sum初始化为0；特别注意这点；
    //累加将sum初始化为0，累乘就要将其初始化为1； 
    scanf("%d",&n);//输入数n 
    for(i = 0; i < n; i++){//接收n个数，并进行累加求出n个数的和 
        scanf("%lf",&a[i]);
        sum += a[i];
    }
    avg = sum/n;//计算平均数；注意除法的规则； 
    printf("%lf\n",avg);
    for(i = 0; i < n; i++){
        printf("%g ",a[i]);//%g输出实数的时候会自动输出截取0 
    }

    return 0;
} 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

2；计算最大最小值
/*
    程序； 输出最大值最小值；
        先输入一个数n代表有几个数，
        接下来输入n个数，
        再输出这n个数中的最大最小值并且在下一行输出这n个数；
    一般的步骤就是；先对max，min进行赋值，将a[0]赋值，再对数组进行遍历比较 
*/
#include<stdio.h>
int main()
{
    int i, n, min, max;
    int a[100];
    scanf("%d",&n);
    for(i = 0; i < n; i++){//接收数组的值 
        scanf("%d",&a[i]);
    } 
    min = max = a[0];//对max，min两个变量进行初始化 
    for(i = 1; i < n; i++){//max，min对数组进行遍历 
        if(min > a[i]){
            min = a[i];
        }
        if(max < a[i]){
            max = a[i];
        }
    } 
    printf("max = %d\nmin = %d \n",max,min);
    for(i = 0; i < n; i++){//输出数组元素； 
        printf("%d ",a[i]);
    } 

    return 0;
} 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

3；正序逆序输出
/*
    程序；输入n，表示要接收n个奇数进行，将这n个奇数进行正序逆序输出； 

*/ 
#include<stdio.h>
int main()
{
    int n,l,i;
    int a[100];
    scanf("%d",&n);//表示要有n个奇数 
    l = 0;//标记数组的下标 当l==n时就表示有n个元素了 
    for(i = 0; l!=n; i++){ 
        if(i%2 == 1){//判断是奇数的时候才进入进行赋值 
            a[l++] = i;//l的后增 
        }
    }
    printf("数组元素正序输出");
    for(i = 0; i < l; i++){
        printf("%d ",a[i]);
    }
    printf("\n数组元素逆序输出");
    for(i = l-1; i >= 0; i--){
        printf("%d ",a[i]);
    }

    return 0;
} 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

4，冒泡排序（上升）
/*
    程序；对数组进行一下排列；冒泡排序； 
    冒泡排序中每次循环的目的使得这组循环中数组元素的最后一个元素为最大值，每次循环最后一个元素将不参加下次循环了。
    （代码未进行简化）
    关键再于；数组与循环的结合；
    两重循环达到排序的目的； 
*/ 
#include<stdio.h>
#define N 10
int main()
{
    int i,j,temp,k;
    int a[N]={1,0,4,6,5,9,2,3,8,7};
    //两重循环的作用；外循环N-1次；每次外循环内部都从a[0]遍历到a[N-1-i]并且交换
    //使得最后的a[N-1-i]是最大的。
    //因此循环N-1次之后，数组就按从小到大的顺序排列好了；
    //每一次外循环就是找到一个最大值放到数组的最后元素， 
    for(i = 0; i < N-1; i++){//循环N-1次； 
        for(j = 0; j < N-1-i; j++){//每次外循环里面还内部循环N-1-I次； 
            if(a[j] > a[j+1]){//进行比较交换 
                temp = a[j + 1];
                a[j + 1] = a[j];
                a[j] = temp;
            }
        } 
        printf("第%d次循环后  ",i+1); 
        for(k = 0; k < N; k++){//只是进行输出的 
            printf("%d ",a[k]);
        }
        printf("\n");
    }
    for(i = 0; i < N; i++){
        printf("%d ",a[i]);
    }

    return 0;
}  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

5；选择排序（上升）
/*
    程序；选择排序；
    每次循环的目的在于找到最小值的下标与这组循环的第一个元素交换
    这样达到，每次循环都找到一个最小值放到前面，再从下个元素又开始下次循环； 


*/
#include<stdio.h>
#define N 10
int main()
{
    int i,j,temp,k,min;
    int a[N]={1,0,4,6,5,9,2,3,8,7};
    for(i = 0; i < N-1; i++){ 
        min = i;//将这组循环中元素的最小值的下标赋值为min 
        for(j = i+1; j < N; j++){//从i+1遍历到N-1； 
            if(a[min] > a[j]){//找到这组循环的最小值的下标赋值给min； 
                min = j;
            }
        }
        //用刚标记下的最小值与第i个元素标志；
        temp = a[min]; 
        a[min] = a[i];
        a[i] = temp;
        //这样就达到；每次循环都是这次循环的首元素变为其中的最小值 
        printf("第%d次排序的结果； ");
        for(k = 0; k < N; k++){
            printf("%d ",a[k]);
        }
        printf("\n"); 
    } 

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

5；二维数组；
5.1；二维数组的定义
二维数组定义的一般形式是：
类型说明符 数组名[常量表达式1][常量表达式2]
其中常量表达式1表示第一维下标的长度，常量表达式2 表示第二维下标的长度。
一维可省略二维不能省略例如可以这样定义int a[][3];也是可以通过编译的，
例如：
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]
在C语言中，二维数组是按行排列的。即，先存放a[0]行，再存放a[1]行，最后存放a[2]行。每行中有四个元素也是依次存放。由于数组a说明为int类型，该类型占两个字节的内存空间，所以每个元素均占有两个字节。
5.2；二维数组元素的引用
二维数组的元素也称为双下标变量，其表示的形式为：
数组名[下标][下标]
其中下标应为整型常量或整型表达式。例如：
a[3][4]
表示a数组三行四列的元素。

5.3；二维数组的初始化
二维数组初始化也是在类型说明时给各下标变量赋以初值。二维数组可按行分段赋值，也可按行连续赋值。
例如对数组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};
这两种赋初值的结果是完全相同的。
但是我们一般采用的是分段的，形象点，不宜出错；
关于初始化与一维数组一样，同样存在部分初始化。
int a [3][3]={{0,1},{0,0,2},{3}};
赋值后的元素值为：
0 1 0
0 0 2
3 0 0

5.4；二维数组可以看作是由一维数组的嵌套而构成的
如二维数组a[3][4]，可分解为三个一维数组，其数组名分别为：
a[0]
a[1]
a[2]
对这三个一维数组不需另作说明即可使用。这三个一维数组都有4个元素，例如：一维数组a[0]的元素为a[0][0],a[0][1],a[0][2],a[0][3]。必须强调的是，a[0],a[1],a[2]不能当作下标变量使用，它们是数组名，不是一个单纯的下标变量。
这个一般在国二选择题中出现；a[i]表示的是a[i]【0】的地址，是表示指向a[i]【0】的指针。
看程序，可以看出a[i]的操作；

5.5；二维数组数组名的介绍；
关于数组名介绍，看我之前写的博客，其中有详细介绍；
链接；
http://blog.csdn.net/zw1996/article/details/53613195

5.6；一些关于二维数组的小程序；

1，找最大最小值及其位置
/*
    程序；找到二维数组的最大最小值以及其二维数组的具体位置
            并且将该二维数组输出； 

*/
#include<stdio.h>
int main()
{
    int min,minx,miny,max,maxx,maxy,i,j; 
    int a[4][4]={{1,2,3,4},{5,6,7,8},{9,0,1,2}};//初始化 
    min = max = a[0][0];//先假设最大最小值为第一个元素 
    minx = miny = maxx = maxy = 0;//其下标假设为第一个元素的下标 
    for(i = 0; i < 4; i++){
        for(j = 0; j < 4; j++){//两重for循环进行遍历二维数组； 
            printf("%d ",a[i][j]);//输出 
            if(min > a[i][j]){//进行判断赋值 
                min = a[i][j];
                minx = i;
                miny = j;
            }
            if(max < a[i][j]){
                max = a[i][j];
                maxx = i;
                maxy = j;
            }
        }
        printf("\n");
    }
    printf("该二维数组的最大值为%d,其数组位置为，第%d行第%d列\n",max,maxx+1,maxy+1);
    printf("该二维数组的最小值为%d,其数组位置为，第%d行第%d列\n",min,minx+1,miny+1);


    return 0;
} 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

2，
/*
    程序； 求二维数组的总和和平均值，每行每列的和 

*/
#include<stdio.h>
int main()
{
    int sum1,sum2,sum3,i,j;
    int a[2][2]={{1,2},{3,4}};
    sum1 = 0;
    for(i = 0; i < 2; i++){
        for(j = 0; j < 2; j++){
            sum1 += a[i][j];
        }
    }
    printf("整个二维数组的和为%d\n",sum1);
    for(i = 0; i < 2; i++){
        sum2 = 0;
        for(j = 0; j < 2; j++){
            sum2 += a[i][j];
        }
        printf("二维数组的第%d行的和为%d\n",i+1,sum2);
    }
    for(i = 0; i < 2; i++){
        sum3 = 0;
        for(j = 0; j < 2; j++){
            sum3 += a[j][i];
        }
        printf("二维数组的第%d列的和为%d\n",j+1,sum3);
    }


    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

3；求该二维数组的对角线之和 
/*
    程序；求该数组的对角线之和 
    左对角线之和判断条件是：行列加和绝对等于当前数组的最大长度减一；
    右对角线之和判断条件是：行列都相等； 

*/
#include <stdio.h>
int main()
{
    int a[3][3]={{23,46,11},{99,45,82},{72,90,21}};
    int s1=0,s2=0;
    int i,j;
    printf("输出的标准格式如下：\n");
    for(i=0;i<3;i++){
        for(j=0;j<3;j++){
            printf("%d ",a[i][j]);
        }
        printf("\n");
    }
    for(i=0;i<3;i++){
        for(j=0;j<3;j++){
            if(i+j==2){
            s1=s1+a[i][j];
            }
        }
    }
    //左对角线之和判断条件是：行列加和绝对等于当前数组的最大长度减一；
    printf("该数组的左对角线和是：= %d\n",s1);
    for(i=0;i<3;i++){
        for(j=0;j<3;j++){
            if(i==j){
                s2=s2+a[i][j];
            }
        }
    }
    //右对角线之和判断条件是：行列都相等； 
    printf("该数组的右对角线和是：= %d\n",s2);

} 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

4；将矩阵倒置；
/*
    程序；将数组进行行列互换【矩阵互换】 
    必须要申请一个数组，要求长度不变，行列是互换的；
    在遍历原数组的时候，只要保证行列的循环变量颠倒位置即可
*/
#include <stdio.h>
int main(){
    int a[3][3]={{23,46,11},{99,45,82},{72,90,21}};
    int b[3][3]; 
    int i,j;
    printf("输出的标准格式如下：\n");
    for(i=0;i<3;i++){
        for(j=0;j<3;j++){
            printf("%d ",a[i][j]);
        }
        printf("\n");
    }
    for(i=0;i<3;i++){
        for(j=0;j<3;j++){
            b[i][j]=a[j][i];//行列的循环变量颠倒位置即可
        }
    }
    printf("\n行列互换后：\n");

    for(i=0;i<3;i++){
        for(j=0;j<3;j++){
            printf("%d ",b[i][j]);
        }
        printf("\n");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

数组差不多就介绍到这里了。