全国计算机等级考试二级教程-C语言程序设计_第9章_数组

四维数组，可用于航天卫星，三维+时间

 #define _CRT_SECURE_NO_WARNINGS

 #include<stdio.h>
 #include<stdlib.h>

 main()
 {
     int a[][][][];
     int i, j, k, l;
     int num = ;
     int *p;
     int find = ;

     printf("%d\n", sizeof(a));
     printf("%d\n", sizeof(a) / sizeof(int));

     for (p = &a[][][][];p < &a[][][][] + ;p++)
     {
         *p = num;
         num++;
     }

     for (i = ;i < ;i++)
     {
         for (j = ;j < ;j++)
         {
             for (k = ;k < ;k++)
             {
                 for (l = ;l < ;l++)
                 {
                     printf("%7d", *(*(*(*(a + i) + j) + k) + l));
                 }
                 printf("\n");
             }
             printf("\n");
         }
         printf("\n");
     }

     system("pause");
 }

//数组作为函数的参数，二维数组用指向一维数组的指针变量

 #define _CRT_SECURE_NO_WARNINGS

 #include<stdio.h>
 #include<stdlib.h>

 //数组作为函数的参数，二维数组用指向一维数组的指针变量
 void showb12(int(*p)[])
 {
     int i, j;

     for (i = ;i < ;i++)
     {
         for (j = ;j < ;j++)
         {
             printf("%6d", p[i][j]);
         }
         printf("\n");
     }
 }

 main()
 {
     int b[][] = { {,,,},{,,,},{,,,} };

     showb12(b);

     system("pause");
 }

行指针

//p[i][j]等价于 *(*(p + i) + j)

 #define _CRT_SECURE_NO_WARNINGS

 #include<stdio.h>
 #include<stdlib.h>
 #include<time.h>

 main()
 {
     int a[][] = { ,,,,,,,,,,, };

     int(*p)[] = a;//二维数组的指针就是一个指向一维数组的指针，元素是确定的

     int i, j;

     scanf("%d %d", &i, &j);

     printf("%d,%d,%d,%d", i, j, p[i][j], *(*(p + i) + j));
     //p[i][j]等价于 *(*(p + i) + j)

     system("pause");
 }

//a[i][j]等价于*(a[i]+j)等价于*(*(a+i)+j)
//&a[i][j]等价于*(a+i)+j

 #define _CRT_SECURE_NO_WARNINGS

 #include<stdio.h>
 #include<stdlib.h>

 main()
 {
     int a[][] = { ,,,,,,,,,,, };
     int i, j;

     for (i = ;i < ;i++)
     {
         for (j = ;j < ;j++)
         {
             printf("%3d,%x", a[i][j], &a[i][j]);
         }
         printf("\n");
     }

     printf("%x,%x,%x\n", a, a + , a + );//三者完全等价，a是一个行指针，代表某一行的首地址
     printf("%x,%x,%x\n", *a, *(a + ), *(a + ));//三者完全等价，a是一个行指针，代表某一行的首地址
     printf("%x,%x,%x\n", a[], a[], a[]);//三者完全等价，a是一个行指针，代表某一行的首地址
     printf("%d,%x\n", a[][], &a[][]);
     //a[i][j]等价于*(a[i]+j)等价于*(*(a+i)+j)
     //&a[i][j]等价于*(a+i)+j

     system("pause");
 }

//a是一个行指针，指向一个有4个元素的数组，4*4=16 行指针
//&a是一个指向二维数组的指针，二维数组有12个元素，4*12=48，整个二维数组
//*a是一个指向int类型数据的指针，列指针

 #define _CRT_SECURE_NO_WARNINGS

 #include<stdio.h>
 #include<stdlib.h>

 main()
 {
     int a[][] = { ,,,,,,,,,,, };

     printf("%x,%x,%x\n", a, &a, *a);
     printf("%d,%d,%d", sizeof(*a), sizeof(*&a), sizeof(**a));
     //*a是一个行指针，指向一个有4个元素的数组，4*4=16
     //*&a是一个指向二维数组的指针，二维数组有12个元素，4*12=48
     //**a是一个指向int类型数据的指针

     system("pause");
 }

//两者地址一样，有何不同？

 #define _CRT_SECURE_NO_WARNINGS

 #include<stdio.h>
 #include<stdlib.h>

 main()
 {
     int a[] = { ,,,, };

     printf("%x,%x\n", a, &a);//两者地址一样，有何不同？

     printf("%d,%d", sizeof(*a), sizeof(*(&a)));
     //4 20

     system("pause");
 }

int *p = a;//指向元素的指针
int(*pa)[5] = &a;//指向数组的指针

 #define _CRT_SECURE_NO_WARNINGS

 #include<stdio.h>
 #include<stdlib.h>
 #include<time.h>

 main()
 {
     int a[] = { ,,,, };

     int *p = a;//指向元素的指针
     int(*pa)[] = &a;//指向数组的指针

     printf("%d,%d\n", sizeof(*p), sizeof(*pa));

     system("pause");
 }

输出结果：

4,20
请按任意键继续. . .

创建一个10个元素的数组，并为其随机赋值。找出最大值。用传统方法，和指针方法。

#define _CRT_SECURE_NO_WARNINGS

#include<stdio.h>
#include<stdlib.h>
#include<time.h>

main()
{
    time_t ts;
    srand((unsigned int)time(&ts));

    int num[];
    int i;
    int max = ;//保存最大数

    for (i = ;i < ;i++)
    {
        num[i] = rand() % ;
        printf("%d,%x\n", num[i], &num[i]);
    }

    for (i = ;i < ;i++)//传统方法
    {
        if (num[i] > num[max])
        {
            max = i;
        }
    }

    printf("%d,%d\n", max, num[max]);

    for (i = ;i < ;i++)//指针方法
    {
        if (*(num + i) > num[max])
        {
            max = i;
        }
    }

    printf("%d,%d\n", max, num[max]);

    system("pause");
}

用带下标的指针变量引用一维数组元素

4种方法：

 #define _CRT_SECURE_NO_WARNINGS

 #include<stdio.h>
 #include<stdlib.h>

 main()
 {
     int num[] = { ,,,,,,,,, };
     int i;
     int *p = num;
     //p是变量，num是常量
     for (i = ;i < ;i++)
     {
         printf("%d,%x", num[i], &num[i]);
         printf("%3d,%x", *(num + i), num + i);
         printf("%3d,%x", p[i], &p[i]);
         printf("%3d,%x\n", *(p + i), p + i);
     }

     system("pause");
 }

printf("%d", (p1 - p2));//-2数组至今可以判断哪个编号在前，哪个编号在后
//并且可以判断两个指针之间相隔多少个元素
//指针相减，可以判断下标，p1<p2，p1对应元素的下标小于p2对应元素的下标

 #define _CRT_SECURE_NO_WARNINGS

 #include<stdio.h>
 #include<stdlib.h>

 main()
 {
     int a[] = { ,,,,,,,,, };

     int *p1 = &a[];
     int *p2 = &a[];

     printf("%d", (p1 - p2));//-2数组至今可以判断哪个编号在前，哪个编号在后
     //并且可以判断两个指针之间相隔多少个元素
     //指针相减，可以判断下标，p1<p2，p1对应元素的下标小于p2对应元素的下标
     system("pause");
 }

指针比较，在数组才有意义。

 #define _CRT_SECURE_NO_WARNINGS

 #include<stdio.h>
 #include<stdlib.h>

 main()
 {
     int a[] = { ,,,, };
     printf("%x\n", a);
     int *p1 = &a[];
     int *p2 = &a[];

     if (p1 < p2)
     {
         printf("p1在数组内部排列比较靠前");
     }
     else
     {
         printf("p2在数组内部排列比较靠前");
     }

     system("pause");
 }

指针的加减法在非数组内部没有任何意义，而且很容易越界报错。

一个exe不能读写其他exe进程的内存

p = p + 2;//指针+2，在数组内部等价于向后移动2个元素的大小

p = p - 3;//指针-3，在数组内部等价于向前移动3个元素的大小

 #define _CRT_SECURE_NO_WARNINGS

 #include<stdio.h>
 #include<stdlib.h>

 main()
 {
     int a[] = { ,,,, };
     int *p = &a[];

     printf("%d\n", a[]);

     p = p + ;//指针+2，在数组内部等价于向后移动2个元素的大小

     printf("%d\n", *p);

     p = p - ;//指针-3，在数组内部等价于向前移动3个元素的大小

     printf("%d\n", *p);

     system("pause");
 }

指针++，指针--

 #define _CRT_SECURE_NO_WARNINGS

 #include<stdio.h>
 #include<stdlib.h>

 main()
 {
     int a[];
     int i = ;
     int *p;

     printf("%x\n", a);

     //从头到尾扫描数组
     for (p = a;p < a + ;p++)//指针++，就是指针每次向前移动sizeof(指针类型)个字节
     {
         *p = i;//对指针指向的内容进行赋值
         i++;
     }

     //从尾到头扫描数组
     for (p = a + ;p >= a;p--)//指针++，就是指针每次向前移动sizeof(指针类型)个字节
     {
         printf("%x\n", p);
         *p = i;//对指针指向的内容进行赋值
         i++;
     }

     system("pause");
 }

通过数组的首地址引用数组元素

 #define _CRT_SECURE_NO_WARNINGS

 #include<stdio.h>
 #include<stdlib.h>

 main()
 {
     int a[] = { ,,,,,,,,, };

     printf("%x\n", a);

     printf("%d\n", *(a + ));//两者等价
     printf("%d\n", a[]);//两者等价

     system("pause");
 }

*p = *p - 1;//取指针变量p所指存储单元中的值，减1后再放入p所指的存储单元中，即使得值减1

 #define _CRT_SECURE_NO_WARNINGS

 #include<stdio.h>
 #include<stdlib.h>

 main()
 {
     int a[] = { ,,,,,,,,, };
     int i;
     int *p;

     printf("%x\n", a);//a被编译器解析为数组的首地址

     for (i = ;i < ;i++)//下标循环，通过下标方式访问数组
     {
         printf("%d,%d\n", a[i], *(a + i));//a[i], *(a + i)两者等价
         printf("%x,%x\n", &a[i], a + i);//&a[i], a + i两者等价
     }

     for (p = a;p < a + ;p++)//指针循环，通过指针方式访问数组
     {
         *p = *p - ;//取指针变量p所指存储单元中的值，减1后再放入p所指的存储单元中，即使得值减1
         printf("%d,%x\n", *p, p);
     }

     system("pause");
 }

数组当作参数的时候，传递的是指针

 #define _CRT_SECURE_NO_WARNINGS

 #include<stdio.h>
 #include<stdlib.h>

 void fun(int a[])//数组当作参数的时候，传递的是指针
 {
     printf("%d\n", sizeof(a));//
 }

 main()
 {
     int a[] = { ,,,,,,,,, };

     printf("%d\n", sizeof(a));//

     fun(a);

     system("pause");
 }

创建一个动态二维数组，连续内存

 #define _CRT_SECURE_NO_WARNINGS

 #include<stdio.h>
 #include<stdlib.h>
 #include<time.h>

 main()
 {
     int x, y;

     scanf("%d %d", &x, &y);

     void *p = malloc(sizeof(int)*x*y);//分配内存，连续的内存
     //y必须是一个已知的常量，才能将这片内存当作一个二维数组来实现
     //连续内存，缺点：列必须是常量指定的

     int(*px)[] = p;
     int i, j;
     int num = ;

     for (i = ;i < x;i++)
     {
         for (j = ;j < ;j++)
         {
             px[i][j] = num;
             num++;
             printf("%4d", px[i][j]);
         }
         printf("\n");
     }

     system("pause");
 }

创建一个动态二维数组，不连续内存

 #define _CRT_SECURE_NO_WARNINGS

 #include<stdio.h>
 #include<stdlib.h>

 main()
 {
     int x, y;

     scanf("%d %d", &x, &y);

     //二级指针可以存储指针数组的地址
     //动态分配一片内存，存放指针数组，每一个元素都是一个地址
     //然后将指针数组的首地址传递给pp保存
     int **pp = malloc(sizeof(int *)*x);
     int i, j;
     int num = ;

     for (i = ;i < x;i++)
     {
         pp[i] = malloc(sizeof(int)*y);
     }

     for (i = ;i < x;i++)
     {
         for (j = ;j < y;j++)
         {
             pp[i][j] = num;//等价于*(*(pp+i)+j)
             num++;
             printf("%4d", pp[i][j]);
         }
         printf("\n");
     }

     //释放内存

     for (i = ;i < x;i++)
     {
         free(pp[i]);
     }
     free(pp);

     system("pause");
 }

二维数组，一个指针指向类型的大小，恰好要是一个一维数组的大小；二维数组是一个一维数组，每一个元素都是一个一维数组。

 #define _CRT_SECURE_NO_WARNINGS

 #include<stdio.h>
 #include<stdlib.h>
 #include<time.h>

 main()
 {
     int a[][] = { ,,,,,,,,,,, };
     int i, j;
     int(*p)[] = a;//创建一个指针存储二维数组的首地址，一个指向有4个元素的一维数组的指针

     for (i = ;i < ;i++)
     {
         for (j = ;j < ;j++)
         {
             printf("%5d", a[i][j]);
         }
         printf("\n");
     }

     for (int *p = &a[][];p < &a[][] + ;p++)
     {
         printf("%d,%p\n", *p, p);
     }

     system("pause");
 }

求出数组元素的个数：

 #define _CRT_SECURE_NO_WARNINGS

 #include<stdio.h>

 main()
 {
     int a[] = { ,,,, };

     printf("%x\n", a);

     printf("%d", sizeof(a) / sizeof(int));

     system("pause");
 }

数组

为什么需要数组？

为了解决大量同类型数据的存储和使用问题

为了模拟现实世界

怎样定义一维数组？

为n个变量连续分配存储空间

所有的变量数据类型必须相同

所有变量所占的字节大小必须相等

指针变量的运算：

指针变量不能相加，不能相乘，也不能相除。

如果两个指针变量指向的是同一块连续空间中的不同存储单元，则这两个指针变量才可以相减。（即：在同一数组中相减，求出两个指针指向的单元相隔的单元数）

 #include<stdio.h>
 main()
 {
     int a[];
     int * p = &a[];
     int * q = &a[];

     printf("p和q所指向的单元相隔%d个单元\n", q - p);
 }

一堆数组的初始化

 #include <stdio.h>
 main()
 {
     int a[] = { ,,,, };   /*完全初始化*/  

     int a[] = { ,, };   /*不完全初始化，未被初始化的元素自动为零*/  

     int a[];   /*不初始化，所有元素是垃圾值*/  

     int a[] = {  };   /*清零*/  

     /*错误写法*/
     int a[];
     a[] = { ,,,, };   /*错误，只有在定义数组的同时才可以整体赋值，其他情况下整体赋值都是错误的*/  

     int a[] = { ,,,, };
     a[] = ; /*错误，因为没有a[5]这个元素，最大是a[4]*/  

     /*如果要把a数组中的值全部复制给b数组*/
     int a[] = { ,,,, };
     int b[];
     b = a;  /*错误的写法*/  

     for (i = ;i < ;++i)
         b[i] = a[i];    /*正确的写法*/
 }

 #include <stdio.h>
 main()
 {
     int a[];
     //int b[5];

     //a = b;        /* ERROR a是常量 */

     printf("%#X\n", &a[]);
     printf("%#X\n", a);
 }

输出结果：

0XDEF9B4
0XDEF9B4
请按任意键继续. . .

 #include <stdio.h>

 void f(int * a, int len)
 {
     int i;

     for (i = ;i < len;++i)
     {
         printf("%d ", *(a + i));        /* 两者输出都一样 */
     }
     printf("\n");

     for (i = ;i < len;++i)
     {
         printf("%d ", a[i]);        /* 两者输出都一样 */
     }
     printf("\n");
 }

 main()
 {
     int a[] = { ,,,, };

     f(a, );        /* 因为a是存放地址，所以a是int * */
 }

例9.1 编写程序，定义一个含有30个元素的 int 类型数组。依次给数组元素赋奇数1、3、5、...，然后按每行10个数顺序输出，最后再按每行10行个数逆序输出。

 #include <stdio.h>
 #define M 30
 main()
 {
     int s[M], i, k = ;
     for (i = ;i < M;i++)        /* 给s数组元素依次赋1、3、... */
     {
         s[i] = k;
         k += ;
     }

     printf("\nSequence Output:\n");        /* 按从前到后的顺序输出 */

     for (i = ;i < M;i++)
     {
         printf("%4d", s[i]);
         if ((i + ) %  == )
             printf("\n");        /* 利用i控制换行符的输出 */
     }

     printf("\nInvert Output:\n");        /* 按从后到前的顺序输出 */

     for (i = M - ;i >= ;i--)        /* 下标值从大到小 */
     {
         printf("%4d", s[i]);
         if (i %  == )
             printf("\n");        /* 利用i控制换行符的输出 */
     }
 }

例9.2 编写程序，通过一个函数给主函数中定义的数组输入若干大于或等于0的整数，用负数作为输入结束标志；调用另一个函数输出该数组中的数据。

 #include <stdio.h>
 #define M 100
 void arrout(int *, int);        /* 函数说明语句，此函数用以输出数组中的值 */
 int arrin(int *);        /* 函数说明语句，此函数用以给数组输入数据 */
 main()
 {
     int s[M], k;
     k = arrin(s);        /* k得到输入数据的个数 */
     arrout(s, k);
 }

 int arrin(int * a)
 {
     int i, x;
     i = ;
     scanf("%d", &x);
     while (x >= )
     {
         *(a + i) = x;
         i++;
         scanf("%d", &x);
     }
     return i;
 }

 void arrout(int * a, int n)
 {
     int i;
     for (i = ;i < n;i++)
     {
         printf(((i + ) %  == ) ? "%4d\n" : "%4d", *(a + i));
     }
     /* 根据i的值来确定使用不同的格式串 */
     printf("\n");
 }

例9.3 编写函数，对具有10个元素的char类型数组，从下标为4的元素开始，全部设置星号 “ * ” ，保持前4个元素中的内容不变。

 #include <stdio.h>
 #define M 10
 #define B 4
 void setstar(char *, int);
 void arrout(char *, int);
 main()
 {
     char c[M] = { 'A','B','C','D','E','F','G','H','I','J' };
     setstar(&c[], M - B);
     arrout(c, M);
 }

 void setstar(char * a, int n)
 {
     int i;
     for (i = ;i < n;i++)
     {
         *(a + i) = '*';
     }
 }

 void arrout(char * a, int n)
 {
     int i;
     for (i = ;i < n;i++)
     {
         printf("%c", a[i]);
     }
     printf("\n");
 }

例9.4 编写程序，定义一个含有15个元素的数组，并编写函数分别完成以下操作：

（1）调用C库函数中的随机函数给所有元素赋以0~49的随机数；

（2）输出数组元素中的值；

（3）按顺序对每隔三个数求一个和数，并传回主函数；

（4）最后输出所有求出的和值。

 #include <stdio.h>
 #include "stdlib.h"
 #define SIZE 15
 #define N 3
 void getrand(int *, int);        /* 三个函数说明语句 */
 void getave(int *, int *, int);
 void priarr(int *, int);
 main()
 {
     int x[SIZE], w[SIZE / N] = {  };        /* w数组中置初值0，准备存放5个和值 */
     getrand(x, SIZE);        /* 产生15个随机数放入x数组中 */
     printf("Output %d random numbers:\n", SIZE);
     priarr(x, SIZE);        /* 输出15个随机数 */
     getave(x, w, SIZE);        /* 每3个数求一个和数放入w数组 */
     printf("Output 5 sum numbers:\n");
     priarr(w, SIZE / N);        /* 输出5个和数 */
 }

 void getrand(int * a, int n)
 {
     int i;
     for (i = ;i < n;i++)
     {
         a[i] = rand() % ;
     }
 }

 void getave(int * a, int * b, int n)
 {
     int i, j, sum;
     for (sum = , i = , j = ;i <= n;i++)
     {
         sum += a[i];        /* 累加数组元素 */
         if ((i + ) %  == )        /* 每累加3个数进行一次处理 */
         {
             b[j] = sum;        /* 和值放入w数组中 */
             sum = ;        /* 置0，准备重新累加 */
             j++;        /* 下标增1 */
         }
     }
 }

 void priarr(int * a, int n)
 {
     int i;
     for (i = ;i < n;i++)
     {
         printf("%5d", a[i]);
         if ((i + ) %  == )
             printf("\n");
     }
     printf("\n");
 }

例9.5 将数组中的数按颠倒的顺序重新存放。在操作时，只能借助一个临时存储单元而不得另外开辟数组。

 #include <stdio.h>
 #define NUM 8
 void invert(int *, int);        /* 函数说明语句 */
 void priout(int *, int);        /* 函数说明语句 */
 main()
 {
     /* 用置初值的方法给a数组放入数据 */
     int a[NUM] = { ,,,,,,, };
     printf("Output primary data:");        /* 输出原始数据 */
     priout(a, NUM);
     invert(a, NUM);
     printf("Output the inverse data:");        /* 输出颠倒后的数据 */
     priout(a, NUM);
 }

 void priout(int s[], int n)
 {
     int i;
     for (i = ;i < n;i++)
     {
         printf("%4d", s[i]);
     }
     printf("\n");
 }

 void invert(int * a, int n)
 {
     int i, j, t;
     i = ;
     j = n - ;        /* i是最前元素的下标，j是最后元素的下标 */
     while (i < j)        /* 当i大于或等于j时，对调完成 */
     {
         t = a[i];
         a[i] = a[j];
         a[j] = t;        /* 下标为i和j的两个元素中的值对调 */
         i++;
         j--;        /* i向后移一个位置，j向前移一个位置 */
     }
 }

例9.6 已知整型数组中的值在0至9的范围内，统计每个整数的个数。

以下程序中，函数 getdata 调用随机函数产生50个值在0至9的整数；函数 stat 统计每个整数的个数，并传回主函数；函数 outdata 输出结果。

 #include <stdio.h>
 #include <stdlib.h>
 #define M 50
 #define N 10

 void getdata(int * s)
 {
     int i;
     for (i = ;i < M;i++)
     {
         s[i] = rand() % ;
         if (i %  == )
         {
             printf("\n");        /* 每生成10个随机数，换行 */
         }
         printf("%d ", s[i]);        /* 把随机数打印出来 */
     }
 }

 void stat(int * a, int * c)
 {
     int i;
     for (i = ;i < N;i++)
     {
         c[i] = ;        /* c数组元素置初值0 */
     }
     for (i = ;i < M;i++)
     {
         c[a[i]]++;        /* 用c数组的元素对各整数进行统计 */
     }
 }

 void outdata(int * c)
 {
     int i;
     for (i = ;i < N;i++)
     {
         printf("%d:%d\n", i, c[i]);
     }
 }

 main()
 {
     int a[M], c[N];
     getdata(a);
     stat(a, c);
     printf("\nOutput the result:\n");
     outdata(c);
 }

例9.7 已知存放在 a 数组中的数不相重，在 a 数组中查找和 x 值相同的元素的位置。若找到，输出该值和该值在 a 数组中的位置；若没找到，输出相应的信息。

以下程序中，arrin 函数用于输入数据。函数首先要求输入一个整数，以确定将给数组输入数据的个数，然后给数组输入数据。

在主函数中输入带查找的数据。

函数 search 用以查找 x 在数组中的位置，位置值传送给变量 p。若 p 的值为 -1，表示在数组中没有值为 x 的元素，否则 p 中的值即为所找的位置。

 #include <stdio.h>
 #define NUM 30

 int arrin(int * a)
 {
     int i, n;
     do        /* 当指定数组元素个数超出范围时，重新输入 */
     {
         printf("Enter number of elements,0<=n<%d:", NUM);
         scanf("%d", &n);
     } while ((n < ) || (n >= NUM));
     /* 注意：输入的n个整数，放入a[0]至a[n-1]中，a[n]在查找时用作辅助空间 */
     printf("Enter %d integer numbers:\n", n);
     for (i = ;i < n;i++)
     {
         scanf("%d", a + i);
     }
     return n;
 }

 int search(int * a, int x, int n)
 {
     int i, p;        /* 查找开始 */
     i = ;        /* 从a[0]元素开始查找 */
     a[n] = x;        /* 把待查找的数放入a[n]中 */
     while (x != a[i])
     {
         i++;
     }
     /* 只要x值等于当前a[i]的值，则推出循环，否则i后移一位 */
     if (i == n)
     {
         p = -;        /* 没找到 */
     }
     else p = i;        /* 找到 */
     return p;
 }

 main()
 {
     int a[NUM], x, n, p;        /* 暂定数组含30个元素，下标的上限为29 */
     n = arrin(a);
     printf("Enter the number to search:x=");
     scanf("%d", &x);
     p = search(a, x, n);
     if (p != -)
     {
         printf("%d index is:%d\n", x, p);        /* 输出x所在下标 */
     }
     else printf("%d is not found!\n", x);        /* 输出没找到信息 */
 }

例9.8 w 数组中存放 n 个数据，编写函数删除下标为 k 的元素中的值。

以下程序中，调用了 getindex、arrout 和 arrdel 三个函数。getindex 用以输入所删元素的下标，函数中对输入的下标进行检查，若越界，则要求重新输入，直到正确为止；arrout 用以输出数组中的数据；arrdel 进行所要求的删除操作。

 #include <stdio.h>
 #define NUM 10        /* 假定数组含有10个元素 */
 int arrdel(int *, int, int);        /* 函数说明语句 */
 void arrout(int *, int);        /* 函数说明语句 */
 int getindex(int n);
 main()        /* 用置初值的方法给数组置数 */
 {
     int n, d, a[NUM] = { ,,,,,,,,, };
     n = NUM;
     printf("Output primary data:\n");        /* 输出原始数据 */
     arrout(a, n);
     d = getindex(n);
     n = arrdel(a, n, d);
     printf("Output the data after delete:\n");        /* 输出删除后的数据 */
     arrout(a, n);
 }

 void arrout(int w[], int m)
 {
     int k;
     for (k = ;k < m;k++)
     {
         printf("%d ", w[k]);
     }
     printf("\n");
 }

 int arrdel(int * w, int n, int k)
 {
     int i;
     for (i = k;i < n - ;i++)
     {
         w[i] = w[i + ];        /* i+1替换i */
     }
     n--;        /* 删除后数据个数减1 */
     return n;
 }

 getindex(int n)
 {
     int i;
     do        /* 当指定的下标值落在数据所在下标范围内时，退出循环，返回该下标值 */
     {
         printf("\nEnter the index [0<=i<%d]:", n);        /* 输入待删元素的下标 */
         scanf("%d", &i);
     } while (i< || i>n - );
     return i;
 }

例9.9 用选择法对数组中的数进行排序（按由小到大顺序）。

 #include <stdio.h>
 #define NUM 6
 void arrsort(int[], int);
 void arrout(int *, int);
 main()
 {
     int a[NUM] = { ,,,,, };
     arrout(a, NUM);        /* 输出a数组中原始数据 */
     arrsort(a, NUM);        /* 对a数组中的数进行排序 */
     arrout(a, NUM);        /* 输出排序后a数组中的数据 */
 }

 void arrsort(int * a, int n)
 {
     int i, j, p, t;
     for (j = ;j < n - ;j++)        /* n个数进行n-1次选择 */
     {
         p = j;        /* 先使p指向排序范围的第一个元素 */
         for (i = j + ;i < n;i++)
         {
             if (a[p] > a[i])
             {
                 p = i;        /* 使p指向a[j]到a[n-1]之间的最小元素的位置 */
             }
         }
         if (p != j)
         {
             t = a[j];
             a[j] = a[p];
             a[p] = t;        /* 如果排序范围的第一个元素不是最小的元素，则将最小的元素的值与排序范围的第一个元素中的值进行对调 */
         }
     }
 }

 void arrout(int a[], int n)
 {
     int i;
     for (i = ;i < n;i++)
     {
         printf("%d", a[i]);
     }
     putchar('\n');
 }

考点：

1

行列下标下限为 0，上限为 n-1

2

一定要把两个下标分别放在两个方括号内

int a[4] [2]合法

int a[0, 1]不合法

3

a[i] [j] 表示第 (i + 1)  行第 (j + 1) 列

第 m 行第n列：a[m-1] [n-1]

int a[m] [n] 该二维数组右下角位置的元素是 a[m - 1] [n - 1]

是否存在多维数组？

不存在多维数组。

因为内存是线性一维的。

n维数组可以当作每个元素是 n - 1 维数组的一维数组

比如：

int a[3][4]

该数组是含有3个元素的一维数组

只不过每个元素都可以再分成4个小元素

int a[3][4][5]

该数组是含有3个元素的一维数组

只不过每个元素都是4行5列的二维数组

例9.10 通过键盘给 2*3 的二维数组输入数据，第一行赋1、2、3，第二行赋10、20、30，然后按行输出此二维数组。

 #include <stdio.h>
 main()
 {
     int a[][], i, j;
     printf("Enter data  by line:\n");
     for (i = ;i < ;i++)
     {
         for (j = ;j < ;j++)
         {
             scanf("%d", &a[i][j]);
         }
     }
     printf("Output a 2-dimension array:\n");
     for (j = ;j < ;j++)
     {
         for (i = ;i < ;i++)
         {
             printf("%4d", a[j][i]);
         }
         printf("\n");
     }
     for (i = ;i < ;i++)
     {
         for (j = ;j < ;j++)
         {
             printf("%4d", a[j][i]);
         }
         printf("\n");
     }
 }

输出格式：

Enter data  by line:
1 2 3 10 20 30
Output a 2-dimension arra
   1   2   3
  10  20  30
   1  10
   2  20
   3  30
请按任意键继续. . .

例9.11 编写程序，通过调用随机函数给 5*6 的二维数组元素赋10~40范围内的整数，求出二维数组每行元素的平均值。

 #include <stdio.h>
 #include <stdlib.h>
 #define M 6        /* 每行6列 */
 #define N 5        /* 数组包含5行 */
 void getdata(int(*)[M]);        /* 得到随机数 */
 void lineave(int[][M], float *);        /* 求每行的平均值 */
 void outdata(int[N][M], float *);        /* 输出数据 */
 main()
 {
     int r[N][M];        /* 用整型数组r存放随机数 */
     float ave[N];        /* 用ave数组存放每行的平均值 */
     getdata(r);        /* 输入数据 */
     lineave(r, ave);        /* 求r数组每行的平均值放在ave数组中 */
     outdata(r, ave);        /* 输出数据 */
 }

 void getdata(int(*sp)[M])
 {
     int i, j, x;
     for (i = ;i < N;i++)
     {
         j = ;
         while (j < M)
         {
             x = rand() % ;        /* 产生0到40的随机数 */
             if (x >= )        /* 只有产生的随机数大于或等于10时才放入数组中 */
             {
                 sp[i][j] = x;
                 j++;
             }
         }
     }
 }

 void lineave(int s[][M], float * a)        /* 求每行的平均值 */
 {
     int i, j;
     float ave;
     for (i = ;i < N;i++)
     {
         ave = 0.0;
         for (j = ;j < M;j++)
         {
             ave = ave + s[i][j];
         }
         a[i] = ave / M;
     }
 }

 void outdata(int sp[N][M], float a[])
 {
     int i, j;
     printf("Output the result:\n");
     for (i = ;i < N;i++)
     {
         for (j = ;j < M;j++)
         {
             printf("%4d", sp[i][j]);
         }
         printf(":%6.2f\n", a[i]);
     }
     putchar('\n');
 }

9.12 行列互换

 #include <stdio.h>
 main()
 {
     int a[][] = { {,,},{,,},{,,} };
     int i, j, t;
     for (i = ;i < ;i++)
     {
         for (j = ;j < ;j++)
         {
             printf("%d ", a[i][j]);
         }
         printf("\n");
     }
     for (i = ;i < ;i++)
     {
         for (j = i + ;j < ;j++)
         {
             t = a[i][j];
             a[i][j] = a[j][i];
             a[j][i] = t;
         }
     }
     for (i = ;i < ;i++)
     {
         for (j = ;j < ;j++)
         {
             printf("%d ", a[i][j]);
         }
         printf("\n");
     }
 }