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

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

#define _CRT_SECURE_NO_WARNINGS

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

main()
{
    int a[2][3][4][5];
    int i, j, k, l;
    int num = 0;
    int *p;
    int find = 116;

    printf("%d
", sizeof(a));
    printf("%d
", sizeof(a) / sizeof(int));
    
    for (p = &a[0][0][0][0];p < &a[0][0][0][0] + 120;p++)
    {
        *p = num;
        num++;
    }

    for (i = 0;i < 2;i++)
    {
        for (j = 0;j < 3;j++)
        {
            for (k = 0;k < 4;k++)
            {
                for (l = 0;l < 5;l++)
                {
                    printf("%7d", *(*(*(*(a + i) + j) + k) + l));
                }
                printf("
");
            }
            printf("
");
        }
        printf("
");
    }

    system("pause");
}

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

#define _CRT_SECURE_NO_WARNINGS

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

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

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

main()
{
    int b[3][4] = { {1,2,3,4},{5,6,7,8},{9,10,11,12} };
    
    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[3][4] = { 0,1,2,3,4,5,6,7,8,9,10,11 };

    int(*p)[4] = 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[3][4] = { 1,2,3,4,5,6,7,8,9,10,11,12 };
    int i, j;

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

    printf("%x,%x,%x
", a, a + 1, a + 2);//三者完全等价，a是一个行指针，代表某一行的首地址
    printf("%x,%x,%x
", *a, *(a + 1), *(a + 2));//三者完全等价，a是一个行指针，代表某一行的首地址
    printf("%x,%x,%x
", a[0], a[1], a[2]);//三者完全等价，a是一个行指针，代表某一行的首地址
    printf("%d,%x
", a[1][2], &a[1][2]);
    //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[3][4] = { 1,2,3,4,5,6,7,8,9,10,11,12 };

    printf("%x,%x,%x
", 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[5] = { 1,2,3,4,5 };

    printf("%x,%x
", 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[5] = { 1,2,3,4,5 };

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

    printf("%d,%d
", 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[10];
    int i;
    int max = 0;//保存最大数
    
    for (i = 0;i < 10;i++)
    {
        num[i] = rand() % 100;
        printf("%d,%x
", num[i], &num[i]);
    }

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

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

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

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

    system("pause");
}

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

4种方法：

#define _CRT_SECURE_NO_WARNINGS

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

main()
{
    int num[10] = { 1,2,3,4,5,6,7,8,9,10 };
    int i;
    int *p = num;
    //p是变量，num是常量
    for (i = 0;i < 10;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
", *(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[10] = { 1,2,3,4,5,6,7,8,9,10 };

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

    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[5] = { 1,2,3,4,5 };
    printf("%x
", a);
    int *p1 = &a[1];
    int *p2 = &a[2];

    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[5] = { 1,2,3,4,5 };
    int *p = &a[2];

    printf("%d
", a[2]);
    
    p = p + 2;//指针+2，在数组内部等价于向后移动2个元素的大小

    printf("%d
", *p);

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

    printf("%d
", *p);

    system("pause");
}

指针++，指针--

#define _CRT_SECURE_NO_WARNINGS

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

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

    printf("%x
", a);

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

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

    system("pause");
}

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

#define _CRT_SECURE_NO_WARNINGS

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

main()
{
    int a[10] = { 1,2,3,4,5,6,7,8,9,10 };

    printf("%x
", a);

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

    system("pause");
}

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

#define _CRT_SECURE_NO_WARNINGS

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

main()
{
    int a[10] = { 1,2,3,4,5,6,7,8,9,10 };
    int i;
    int *p;

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

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

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

    system("pause");
}

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

#define _CRT_SECURE_NO_WARNINGS

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

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

main()
{
    int a[10] = { 1,2,3,4,5,6,7,8,9,10 };

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

    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)[9] = p;
    int i, j;
    int num = 0;

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

    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 = 0;

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

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

    //释放内存

    for (i = 0;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[3][4] = { 1,2,3,4,5,6,7,8,9,10,11,12 };
    int i, j;
    int(*p)[4] = a;//创建一个指针存储二维数组的首地址，一个指向有4个元素的一维数组的指针

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

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

    system("pause");
}

求出数组元素的个数：

#define _CRT_SECURE_NO_WARNINGS

#include<stdio.h>

main()
{
    int a[5] = { 1,2,3,4,5 };

    printf("%x
", a);

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

    system("pause");
}

数组

为什么需要数组？

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

为了模拟现实世界

怎样定义一维数组？

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

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

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

指针变量的运算：

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

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

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

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

一堆数组的初始化

 

#include <stdio.h>  
main()  
{  
    int a[5] = { 1,2,3,4,5 };   /*完全初始化*/  
  
    int a[5] = { 1,2,3 };   /*不完全初始化，未被初始化的元素自动为零*/  
  
    int a[5];   /*不初始化，所有元素是垃圾值*/  
  
    int a[5] = { 0 };   /*清零*/  
  
    /*错误写法*/  
    int a[5];  
    a[5] = { 1,2,3,4,5 };   /*错误，只有在定义数组的同时才可以整体赋值，其他情况下整体赋值都是错误的*/  
  
    int a[5] = { 1,2,3,4,5 };  
    a[5] = 100; /*错误，因为没有a[5]这个元素，最大是a[4]*/  
  
    /*如果要把a数组中的值全部复制给b数组*/  
    int a[5] = { 1,2,3,4,5 };  
    int b[5];  
    b = a;  /*错误的写法*/  
  
    for (i = 0;i < 5;++i)  
        b[i] = a[i];    /*正确的写法*/  
}

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

    //a = b;        /* ERROR a是常量 */
    
    printf("%#X
", &a[0]);
    printf("%#X
", a);
}

输出结果：

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

#include <stdio.h>

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

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

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

main()
{
    int a[5] = { 1,2,3,4,5 };

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

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

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

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

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

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

    for (i = M - 1;i >= 0;i--)        /* 下标值从大到小 */
    {
        printf("%4d", s[i]);
        if (i % 10 == 0)
            printf("
");        /* 利用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 = 0;
    scanf("%d", &x);
    while (x >= 0)
    {
        *(a + i) = x;
        i++;
        scanf("%d", &x);
    }
    return i;
}

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

 

例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[4], M - B);
    arrout(c, M);
}

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

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

 

例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] = { 0 };        /* w数组中置初值0，准备存放5个和值 */
    getrand(x, SIZE);        /* 产生15个随机数放入x数组中 */
    printf("Output %d random numbers:
", SIZE);
    priarr(x, SIZE);        /* 输出15个随机数 */
    getave(x, w, SIZE);        /* 每3个数求一个和数放入w数组 */
    printf("Output 5 sum numbers:
");
    priarr(w, SIZE / N);        /* 输出5个和数 */
}

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

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

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

 

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

#include <stdio.h>
#define NUM 8
void invert(int *, int);        /* 函数说明语句 */
void priout(int *, int);        /* 函数说明语句 */
main()
{
    /* 用置初值的方法给a数组放入数据 */
    int a[NUM] = { 10,20,30,40,50,60,70,80 };
    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 = 0;i < n;i++)
    {
        printf("%4d", s[i]);
    }
    printf("
");
}

void invert(int * a, int n)
{
    int i, j, t;
    i = 0;
    j = n - 1;        /* 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 = 0;i < M;i++)
    {
        s[i] = rand() % 10;
        if (i % 10 == 0)
        {
            printf("
");        /* 每生成10个随机数，换行 */
        }
        printf("%d ", s[i]);        /* 把随机数打印出来 */
    }
}

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

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

main()
{
    int a[M], c[N];
    getdata(a);
    stat(a, c);
    printf("
Output the result:
");
    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 < 1) || (n >= NUM));
    /* 注意：输入的n个整数，放入a[0]至a[n-1]中，a[n]在查找时用作辅助空间 */
    printf("Enter %d integer numbers:
", n);
    for (i = 0;i < n;i++)
    {
        scanf("%d", a + i);
    }
    return n;
}

int search(int * a, int x, int n)
{
    int i, p;        /* 查找开始 */
    i = 0;        /* 从a[0]元素开始查找 */
    a[n] = x;        /* 把待查找的数放入a[n]中 */
    while (x != a[i])
    {
        i++;
    }
    /* 只要x值等于当前a[i]的值，则推出循环，否则i后移一位 */
    if (i == n)
    {
        p = -1;        /* 没找到 */
    }
    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 != -1)
    {
        printf("%d index is:%d
", x, p);        /* 输出x所在下标 */
    }
    else printf("%d is not found!
", 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] = { 21,22,23,24,25,26,27,28,29,30 };
    n = NUM;
    printf("Output primary data:
");        /* 输出原始数据 */
    arrout(a, n);
    d = getindex(n);
    n = arrdel(a, n, d);
    printf("Output the data after delete:
");        /* 输出删除后的数据 */
    arrout(a, n);
}

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

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

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

 

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

#include <stdio.h>   
#define NUM 6
void arrsort(int[], int);
void arrout(int *, int);
main()
{
    int a[NUM] = { 5,7,4,2,8,6 };
    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 = 0;j < n - 1;j++)        /* n个数进行n-1次选择 */
    {
        p = j;        /* 先使p指向排序范围的第一个元素 */
        for (i = j + 1;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 = 0;i < n;i++)
    {
        printf("%d", a[i]);
    }
    putchar('
');
}

 

考点：

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[2][3], i, j;
    printf("Enter data  by line:
");
    for (i = 0;i < 2;i++)
    {
        for (j = 0;j < 3;j++)
        {
            scanf("%d", &a[i][j]);
        }
    }
    printf("Output a 2-dimension array:
");
    for (j = 0;j < 2;j++)
    {
        for (i = 0;i < 3;i++)
        {
            printf("%4d", a[j][i]);
        }
        printf("
");
    }
    for (i = 0;i < 3;i++)
    {
        for (j = 0;j < 2;j++)
        {
            printf("%4d", a[j][i]);
        }
        printf("
");
    }
}

输出格式：

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 = 0;i < N;i++)
    {
        j = 0;
        while (j < M)
        {
            x = rand() % 41;        /* 产生0到40的随机数 */
            if (x >= 10)        /* 只有产生的随机数大于或等于10时才放入数组中 */
            {
                sp[i][j] = x;
                j++;
            }
        }
    }
}

void lineave(int s[][M], float * a)        /* 求每行的平均值 */
{
    int i, j;
    float ave;
    for (i = 0;i < N;i++)
    {
        ave = 0.0;
        for (j = 0;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:
");
    for (i = 0;i < N;i++)
    {
        for (j = 0;j < M;j++)
        {
            printf("%4d", sp[i][j]);
        }
        printf(":%6.2f
", a[i]);
    }
    putchar('
');
}

9.12 行列互换

#include <stdio.h>
main()
{
    int a[3][3] = { {1,2,3},{4,5,6},{7,8,9} };
    int i, j, t;
    for (i = 0;i < 3;i++)
    {
        for (j = 0;j < 3;j++)
        {
            printf("%d ", a[i][j]);
        }
        printf("
");
    }
    for (i = 0;i < 3;i++)
    {
        for (j = i + 1;j < 3;j++)
        {
            t = a[i][j];
            a[i][j] = a[j][i];
            a[j][i] = t;
        }
    }
    for (i = 0;i < 3;i++)
    {
        for (j = 0;j < 3;j++)
        {
            printf("%d ", a[i][j]);
        }
        printf("
");
    }
}