C语言数组试题

第4章 数组

4.1内容概述

本章主要介绍了数值数组和字符数组的定义、初始化、元素引用和数组数据的输入与输出，字符数组实现字符串、字符串函数的实现与调用。指针数组与数组指针定义、元素引用。利用一维数组实现如挑数、排序、求和等实际应用问题。利用二维数组实现矩阵的应用问题。利用字符数组实现字符串的各种操作。本章知识结构如图4.1所示。

定义

初始化

数值数组

元素引用

数组元素输入和输出

定义

初始化 数组 字符数组

元素引用

数组元素输入和输出

定义

指针数组 初始化

应用

图4.1 第4章知识结构图

考核要求：掌握一维数组、二维数组、字符数组和指针数组的定义和初始化；掌握数组元素存储地址计算；掌握数组元素的下标法、指针法引用；掌握字符数组与字符串的区别与联系；掌握有关字符串处理函数的使用方法；能利用一维数组、二维数组解决向量、矩阵等实际应用问题。

重点难点：本章的重点是一维数组、二维数组和字符数组的定义、初始化、元素引用，字符串处理函数的使用。本章的难点是字符串与字符数组的区别，指针数组和数组元素的指针法引用。

核心考点：数组的定义、初始化和数组元素的引用方法，一维数组、二维数组和字符数组的实际应用，字符串的处理方法。

4.2 典型题解析

【例4.1】以下对一维数组a的定义中正确的是（ ）。 A. char a(10); B. int a[0..100];

C. int a[5]; D. int k=10;int a[k]; 解析：一维数组定义的一般形式为：

类型标识符 数组名[常量表达式]

其中，常量表达式可以是任意类型，一般为算术表达式，其值表示数组元素的个数，即数组长度。

答案：C

【例4.2】以下对一维数组的定义中不正确的是（ ）。 A. double x[5]={2.0,4.0,6.0,8.0,10.0};

62

B. int y[5]={0,1,3,5,7,9};

C. char ch1[ ]={'1', '2', '3', '4', '5'}; D. char ch2[ ]={'\\x10', '\\xa', '\\x8'};

解析：可以对一维数组的全部元素或部分元素赋初值。在对全部数组元素初始化时，数组长度可以省略。若数组长度没有省略，则初始化列表中值的个数不能超过数组的长度。

答案:B

【例4.3】以下对二维数组的定义中正确的是（ ）。

A．int a[4][]={1，2，3，4，5，6}; B. int a[][3];

C．int a[][3]= {1，2，3，4，5，6}; D. int a[][]＝{{1,2,3},{4,5,6}};

解析：定义二维数组时，若按一维格式初始化，则第一维的长度可以省略，此时，系统可根据初始化列表中值的个数及第二维的长度计算出省略的第一维长度，但无论如何，第二维的长度不能省略。没有初始化时，每一维的长度都不能省略。

答案：C

【例4.4】假定一个int型变量占用两个字节，若有定义：int x[10]={0,2,4}; 则数组x在内存中所占字节数是（ ）。

A. 3 B. 6 C. 10 D. 20

解析：一维数组在内存中所占的字节数为：数组长度×sizeof(元素类型)。 答案：D

【例4.5】以下程序的输出结果是（ ）。 main()

{ int a[4][4]={{1,3,5},{2,4,6},{3,5,7}};

printf(\}

A. 0650 B. 1470 C. 5430 D. 输出值不定

解析：定义的数组a为4行4列，且前三行三列元素已初始化，根据C语法规定，未初始化的元素值为0。

答案：A

【例4.6】以下程序的输出结果是（ ）。 main()

{ int m[][3]={1,4,7,2,5,8,3,6,9};int i,j,k=2; for(i=0;i<3;i++){ printf(\}

A. 4 5 6 B. 2 5 8 C. 3 6 9 D. 7 8 9

解析：根据初始化列表中值的个数和第二维的长度，可求得第一维长度为3。第一行的元素值依次为1，4，7；第二行元素值依次为2，5，8；第三行元素值依次为3，6，9。循环执行三次，依次输出行标为2的三个元素，即第三行的3个元素。

答案：C

【例4.7】以下程序的输出结果是（ ）。 main()

{ int b[3][3]={0,1,2,0,1,2,0,1,2},i,j,t=0; for(i=0;i<3;i++) for(j=i;j<=i;j++) t=t+b[i][b[j][j]]; printf(\

63

}

A. 3 B. 4 C. 1 D. 9

解析：程序中，引用的b数组元素的行下标为循环变量i，列下标为数组元素b[j][j]。外层循环共进行3次，对于每次外循环，内层循环只执行一次（即j=i），所以变量t 的值为元素b[0][b[0][0]]、b[1][b[1][1]]、b[2][b[2][2]]的和。由于数组元素b[0][0]、b[1][1]、b[2][2]的值分别为0、1、2，所以t的值为：0+0+1+2=3。

答案：A

【例4.8】若有定义：int a[2][4];，则引用数组元素正确的是（ ）。 A. a[0][3] B. a[0][4] C. a[2][2] D. a[2][2+1]

解析：引用二维数组元素时，行下标范围为0～行数-1，列下标范围为0～列数-1。 答案：A

【例4.9】若有定义：int aa[8];，则不能代表数组元素aa[1]地址的是（ ） 。 A. &aa[0]+1 B. &aa[1] C. &aa[0]++ D. aa+1

解析： &aa[1]、&aa[0]+1和aa+1都是数组元素aa[1]的地址。由于&aa[0]是地址值常量，不能进行自加、自减运算，所以选项C不能代表aa[1]地址。

答案：C

【例4.10】下列程序执行后的输出结果是（ ） 。 main()

{ int a[3][3], *p,i;p=&a[0][0]; for(i=0;i<9;i++) p[i]=i+1; printf(\}

A. 3 B. 6 C. 9 D. 随机数

解析：二维数组的物理存储结构为一维，即按行序顺序存储在连续存储空间中。

本题中，p为指向数组元素的指针变量，初始时，p指向a[0][0]。通过指针p实现对对二维数组元素按行依次赋值。a[1][2]即p[5]，其值6。

答案：B

【例4.11】下列程序的输出结果是( )。 main()

{ char a[10]={9,8,7,6,5,4,3,2,1,0},*p=a+5; printf(\}

A. 运行出错 B. a[4]的地址 C. 5 D. 3

解析：初始时，p指向a[5]。由于单目运算符的结合方向为右结合，所以，*--p等价于*（--p），即先执行--p，p指向a[4]，再输出a[4]的值（5）。

答案：C

【例4.12】若有如下定义，则b的值是（ ）。

int a[10]={1,2,3,4,5,6,7,8,9,10},*p=&a[3],b=p[5];

A. 5 B. 6 C. 8 D. 9

解析：p指向a[3]，即p=a+3；b=p[5]，即b=*(p+5)。因此，b=*(a+8)=a[8]=9。 答案：D

【例4.13】若二维数组y有m列，则排在y[i][j]前的元素个数为（ ） A.j*m+i B.i*m+j C.i*m+j-1 D.i*m+j+1 解析：C语言中的二维数组按行存储。行标为i的元素前共有i行元素，元素个数为i*m，

64

每行列标为j的元素前共有j个元素。因此，y[i][j]前的元素个数为i*m+j。

答案：B

【例4.14】若有定义：char a[10],*b=a;，则不能给数组a输入字符串”This is a book”的语句是( )。

A. gets(a) B. scanf(\

解析： gets为字符串输入函数，调用该函数时需给出字符串的存储地址，以回车作为字符串输入的结束，并将回车符转换成为’\\0’。而scanf函数则以回车、空格或跳格作为串输入结束，因此scanf不能输入有空格的字符串。

答案：B

【例4.15】以下程序执行后的输出结果是（ ）。

A. 2 B. 3 C. 4 D. 5 #include \main( )

{ char *p[10]={ \ printf(\} 解析：定义了一个含有10个元素的字符指针数组p，并对前5个元素初始化，其中p[4]指向字符串\，其串长为2。

答案：A 【例4.16】若定义一个名为s且初值为\的字符数组，则下列定义错误的是（ ）。 A．char s[]={’1'，'2'，'3'，'\\0 '}; B．char s[]={\

C．char s[]={\．char s[4]={'1'，'2'，'3'}; 解析：字符数组中所存字符中有’\\0’时，字符数组才能作为字符串使用。选项A是用字符常量对字符数组初始化，且最后一个元素的值为字符串结束标记（’\\0’），所以数组s中存放的就是字符串\；选项D是用字符常量对部分元素初始化，根据 C语言的规定，系统为第四个元素赋初值为空值，即'\\0'，所以数组s中存放的也是字符串\123\。选项B是直接使用字符串\对字符数组初始化；选项C也是使用字符串初始化，但是字符串不是\，而是\＼n\，数组长度为5。

答案：C

【例4.17】下列程序的功能是输入N个实数，然后依次输出前l个实数和、前2个实数和、…、前N个实数和。填写程序中缺少的语句。

#define N 10 main()

{ float f[N],x=0.0;int i; for(i=0;i

{ ① ;

printf(\ } }

解析：分析程序可知，第一个循环实现数据的输入，第二个循环实现求和并输出，程序中缺少的是计算前i个实数和并存入变量x的语句。由于每次循环的x值都是在前一次循环的基础上作累加，即前i个实数和（x）等于前i-1个实数和（x）加上第i个实数f[i-1]，

65

因此，①处应填写：x＝x＋f[i-1]；。

答案：x=x＋f[i－l］; 或 x＋＝f[i－l]; 【例4.18】下面程序的功能是检查一个N×N矩阵是否对称（即判断是否所有的a[i][j]等于a[j][i]）。请填空。 #define N 4

main()

{ int a[N][N]={1,2,3,4,2,2,5,6,3,5,3,7,4,6,7,4}; int i,j,found=0; for(j=0;j

for( ① ;i

if(found) printf(\ else printf(\}

解析：设置判断标志found，初始值为0。对于主对角线以上每个元素，分别与对称元素比较，若不相等，则将found置为1并结束比较。循环结束后，根据found的值确定是否对称。

答案：① i=j+1 ② found=1

【例4.19】编写程序，从一整型数组a的第一个元素开始，每三个元素求和并将和值存入到另一数组中（最后一组可以不足3个元素），最后输出所求的所有和值且每行输出5个值。

解析：用于存储和值的数组设为b，所有元素都初始化为0。从数组a的第一个元素开始，进行累加操作b[j]+=a[i]，累加过程中，数组a的下标每自加3次，数组b的下标自加1次。重复此操作，直到数组a的所有元素累加完为止。输出时，每输出5个元素输出一次换行符\。

#define N 20 #define M N/3+1 main()

{ int a[N],i,j,b[M]={0};

for(i=0;i

if((i+1)%3==0) j++; }

if(N%3==0) j--; for(i=0;i<=j;i++) { printf(\

if((i+1)%5==0) printf(\ } }

【例4.20】已知数组b中存放N个人的年龄，编写程序，统计各年龄段的人数并存入数

66

组d。要求把0至9岁年龄段的人数放在d[0]中，把10至19岁年龄段的人数放在d[1]中，把20至29岁年龄段的人数放在d[2]中，其余依此类推，把100岁(含100)以上年龄的人数都放在d[10]中。

解析：首先将数组d的所有元素都初始化为0，然后从数组b的第一个元素开始判断，如果数组b的元素值大于或等于100，则数组元素d[10]加1，否则，数组元素d[数组b的元素值/10]加1。重复此操作，直到数组b的最后一个元素为止。

#include #define M 11 #define N 20 main()

{ int b[N]={32,45,15,12,86,49,97,3,44,52,17,95,63,14,76,88,54,65,99,102}; int d[M],i;

for(i=0;i

if(b[i]>=100) d[10]++; else d[b[i]/10]++; for(i=0;i

printf(\ printf(\}

【例4.21】编写程序，将一维数组x中大于平均值的数据移至数组的前部，小于等于平均值的数据移至数组的后部。

解析：先计算一维数组x的平均值，然后将大于平均值的数据存入数组y的前部，小于等于平均值的数据存入数组y的后部，最后将数组y复制到数组x。

#include #define N 10 main() { int i,j;

float av,y[N],x[N];

for(i=0;i

for(i=0;i

for(i=j=0;iav)

{ y[j++]=x[i];x[i]=-1;} for(i=0;i

if(x[i]!=-1) y[j++]=x[i]; for(i=0;i

{ x[i]=y[i];printf(\}

【例5.22】已知一维整型数组a中的数已按由小到大的顺序排列，编写程序，删去一维数组中所有相同的数，使之只剩一个。

解析：从数组a的第二个元素开始，与前面保留的最后一个元素作比较，若不相等，则

67

前移。重复此操作，直到数组a的最后一个元素为止。

#include #define N 20 main()

{ int a[N]={ 2,2,2,3,4,4,5,6,6,6,6,7,7,8,9,9,10,10,10,10}; int i,j;

printf(\ for(i=0;i

printf(\ for(j=1,i=1;i

if(a[j-1]!=a[i]) a[j++]=a[i];

printf(\ for(i=0;i

printf(\}

【例4.23】编写程序，把从键盘输入的一个数字字符串转换为一个整数并输出。例如，若输入字符串“-1234”,则函数把它转换为整数值-1234。要求：不得调用C语言提供的将字符串转换为整数的函数。

解析：设存放数字字符串的数组为s，存放对应整型数的变量为n（初始值为0）。若字符串的第一个字符为’-’，则从第二个字符开始，否则从第一字符开始，利用公式n=n*10+s[i]-‘0’进行转换，直到’\\0’为止。

#include #include main()

{ char s[10];long n=0; int i=0;

printf(\ gets(s);

if(s[0]=='-') i++; while(s[i])

{ n=n*10+s[i]-'0';i++;} if(s[0]=='-') n=-n; printf(\}

【例4.24】编写程序，把N×N矩阵A加上矩阵A的转置，存放在矩阵B中。

解析：可先将A的转置存入B，再将A的元素a[i][j]累加到B的元素b[i][j]。也可直接利用转置性质，b[i][j]=a[i][j]+a[j][i]。

#define N 3

#include main()

{ int a[N][N]={{1,2,3},{4,5,6},{7,8,9}},b[N][N]; int i,j;

for(i=0;i

68

b[i][j]=a[i][j]+a[j][i]; for(i=0;i

printf(\ printf(\ } }

【例4.25】编写程序，将二维数组a[N][M]中每个元素向右移一列，最右一列换到最左一列，移动后的数组存到另一个二维数组b中，原数组保持不变。例如：

a?415263 b?645312

解析：将数组a的最后一列元素存入数组b的第1列中，再依次将数组a的第i列存入数组b的第i+1列(0=

#define N 3 #define M 3 main()

{ int a[N][M]={4,5,6,1,2,3,6,7,8},b[N][M],i,j; for(i=0;i

printf(\ printf(\ } }

4.3 自测试题

1. 单项选择题

（1）以下定义语句中，错误的是( )。

A．int a[]={1,2}; B．char *a[3]; C．char s[10]=\． int n=5,a[n]; （2）以下能正确定义二维数组的是( )。

A．int a[][3]; B．int a[][3]={2*3};

C．int a[][3]={}; D．int a[2][3]={{1},{2},{3,4}}; （3）以下程序的输出结果是( )。

A．1 5 9 B．1 4 7 C．3 5 7 D．3 6 9 main()

{ int i,x[3][3]={1,2,3,4,5,6,7,8,9};

for(i=0;i<3;i++) printf(\

69

}

（4）有以下程序, 执行后输出结果是( ) main()

{ int x[8]={8,7,6,5,0},*s; s=x+3;

printf(\}

A. 随机值 B. 0 C. 5 D. 6

（5）若有定义：int a[][3]={1,2,3,4,5,6,7,8}; ,则a数组的行数为( )。

A．3 B．2 C．无确定值 D．1 （6）下列描述中不正确的是 ( )。

A. 字符型数组中可以存放字符串 B. 可以对字符型串进行整体输入、输出

C. 可以对整型数组进行整体输入、输出

D. 不能在赋值语句中通过赋值运算符\对字符型数组进行整体赋值 （7）运行下列程序的输出结果是（ ）。

main()

{ int a[]={1,2,3,4,5},i,*p=a+2; printf(\}

A. 出错，因下标不能为负值 B. 2 C. 1 D. 3 （8）以下printf语句的输出结果是( )。 printf(\

A. 7 B. 6 C. 存在语法错误 D. 不定值

（9）若有语句：char s1[10], s2[10]=\，则能将字符串books赋给数组s1的语句是( )。

A. s1=\ B. strcpy(s1, s2); C. s1=s2; D. strcpy(s2, s1); （10）以下语句或语句组中，能正确进行字符串赋值的是( )。

A. char *sp; *sp=\ B. char s[10]; s=\C. char s[10]; *s=\ D. char *sp=\2. 程序分析题（阅读程序，写出运行结果） （1） main()

{ int x[6],a=0,b,c=14; do

{ x[a]=c%2;a++;c=c/2;}while(c>=1); for(b=a-1;b>=0;b--) printf(\ printf(\} （2） main()

{ int i,n[6]={0};

70

for(i=1;i<=4;i++) { n[i]=n[i-1]*2+1; printf(\ } }

（3）

#include

#include main()

{ char c='a',t[]=\ int n,k,j; n=strlen(t); for(k=0;k

if(t[k]==c) {j=k;break;} else j=-1; printf(\} （4）

#include

main()

{ char str1[20]=\ int i, k, num;

i=strlen(str1); k=strlen(str2); num=i

printf(\} （5）

#include main()

{ static int a[]={1,3,5,7}; int *p[3]={a+2,a+1,a}; int **q=p;

printf(\}

3. 程序填空题

（1）下面程序的功能是将字符数组a中下标值为偶数的元素从小到大排列,其它元素不变。请填空。

#include #include main()

{ char a[]=\ int i,j,k; k=strlen(a); for(i=0;i<=k-2;i+=2)

71

for(j=i+2;j

{t=a[i];a[i]=a[j];a[j]=t;} puts(a);printf(\}

（2）下列程序的功能是在字符串s中找出与字符串t相同的子串的个数。请填空。 #include main()

{ char s[]=\ n=0;q=s; while(*q) { p=q;r=t; while(*r)

if( ③ ) { r++; p++;} else break;

if( ④ ) n++; q++; }

printf(\} （3）下面程序的功能是把给定的字符按其矩阵格式读入数组str中，并输出行号与列号之和为3的数组元素。请填空。

main( )

{ char str[4][3]={'A','b','C','d','E','f','G','h','I','j','K','l'}; int x,y,z;

for(x=0;x<4;x++)

for (y=0; ⑤ ;y++) { z=x+y;

if( ⑥ )

printf(\ } } （4）下面程序的功能是输入一个3×3的实数矩阵，求两条对角线元素中各自的最大值。请填空。

main()

{ float s[3][3],max1,max2,x; int i,j;

for(i=0;i<3;i++) for(j=0;j<3;j++)

{ scanf(\ max1= ⑦ ; for(i=1;i<3;i++)

if(max1

72

max2= ⑧ ;

if(max2

main()

{ long int a[40]={1,1}; int i;

for(i=2;i<40;i++)

a[i]= ⑨ ; for(i=0;i<40;i++)

{ if( ⑩ ) printf(\ printf(\ } }

4. 程序设计题

（1）给定一维整型数组，输入数据并求第一个值为奇数元素之前的元素和。

（2）给定一维整型数组，输入数据并对前一半元素升序排序，对后一半元素降序排序。 （3）输入字符串并统计各数字字符出现的次数。

（4）给定N×N矩阵，输入矩阵元素并互换主次对角线元素值。

（5）给定二维数组a[M][N]，输入数据并将元素按照行序存入到一维数组b中。

4.4 实验题目

（1）数组a中存放N个非0整数，编写程序，将数组a中的所有正数存放在数组的前面，负数存放在数组的后面。

（2）将数组a中的N个元素后移m位，移出的m位顺序存放在数组的前m位。

（3）有5名学生，每名学生有语文、数学、物理和外语四门课的考试成绩，编程统计各学生的总分和平均分，以及所有学生各科的总分和平均分。 （4）将整型N×N矩阵主对角线元素进行升序排序。

（5）将4×4阶矩阵的4个最小值按升序存放在主对角线上。 （6）求N×N矩阵每行最大值的和。

（7）由键盘输入一个字符串，按照ASCII码由小到大的顺序排序，要求删除所输入的重复字符。如输入\，则应输出\。

（8）从键盘输入一个字符串，去掉所有非十六进制字符后转换成十进制数输出。要求如输入\，输出值为：10431。

4.5 思考题

（1）定义二维数组时是否可以省略第一维长度？省略时系统如何计算长度？ （2）定义一维数组与引用一维数组元素时，“[]”内数据的含义是什么？

73

（3）若有定义：int a[3][4],(*q)[4]=a;，则如何利用指针变量q引用数组a的元素？ （4）若有如下定义和语句：

int a[3][4],*p[3];

p[0]=&a[0][0];p[1]=&a[1][0];p[2]=&a[2][0]; 则如何利用指针数组名p引用数组a的元素？ （5）试说明下列两种定义方式的区别。

char a[3][8]={\ char *a[3]={\

4.6 习题解答

1. 单项选择题(下列每小题有4个备选答案,将其中一个正确答案填到其后的括号内) （1）设有定义：int a[10],*p=a;，对数组元素的正确引用是（ ）。

① a[p] ② p[a] ③ *(p+2) ④ p+2

解答：a和p是地址，不可以用作数组元素的下标，所以①②错误，选项④为p之后两个元素的地址即等价于&a[2]，选项③为元素a[2]。

答案：③

（2）若有如下定义，则不能表示数组a元素的表达式是（ ）。 int a[10]={1,2,3,4,5,6,7,8,9,10},*p=a;

① *p ② a[10] ③ *a ④ a[p-a] 解答：因为p初值为a，所以选项①为元素a[0]，选项③也为元素a[0]，选项④为a[0]，选项②元素下标超出下标界限（0~9）。

答案：②

（3）若有如下定义，则值为3的表达式是（ ）。 int a[10]={1,2,3,4,5,6,7,8,9,10},*p=a;

① p+=2,*(p++) ② p+=2,*++p ③ p+=3,*p++ ④ p+=2,++*p

解答：四个表达式都是逗号表达式，表达式的值为第二个式子的值，选项①的p从指向a[0]改变为指向a[2],因此表达式值为3，选项②的p指向a[2],计算*++p时指针指向a[3],表达式值为4，选项③的p指向a[3]，表达式值为4，选项④的p指向a[2]，计算++*p后a[2]元素值变为4。

答案：①

（4）设有定义：char a[10]=\，则*(p+4)的值是（ ）。

① \② ’D’ ③ ’\\0’ ④ 不确定 解答：数组所赋初值为串，数组a[4]及其后的六个元素值都为'\\0',*(p+4)等价于*(a+4)即a[4]。

答案：③

（5）将p定义为指向含4个元素的一维数组的指针变量，正确语句为（ ）。

① int (*p)[4]; ② int *p[4]; ③ int p[4]; ④ int **p[4]; 解答：①定义p为指向含4个整型元素的一维数组的指针变量。②定义了一个有四个元素的指针数组，数组名为p,数组中的每一个元素都是指向整型变量的指针变量。③定义了一个有四个元素的整型数组，数组名为p。④定义了一个有四个元素的二级指针数组，数组名为p,数组中的每一个元素都是指向整型指针变量的指针变量。

答案：①

（6）若有定义int a[3][4];,则输入其3行2列元素的正确语句为（ ）。

74

① scanf(\② scanf(\③ scanf(\④ scanf(\

解答：输入3行2列元素的值，应使用其地址，即&a[2][1],或*(a+2)+1，或a[2]+1，所以③是正确的。

答案：③

（7）下面对指针变量的叙述，正确的是（ ）。

① 指针变量可以加上一个指针变量。 ② 可以把一个整形数赋给指针变量。 ③ 指针变量的值可以赋给指针变量。

④ 指针变量不可以有空值，即该指针变量必须指向某一变量。

解答：指针变量加上一个指针变量没有意义，所以①是错误的。不能把一个整型数直接赋给指针变量，因为类型不匹配，所以②是错误的。指针变量可以有空值(NULL)，即不指向任何变量，所以④是错误的。指针变量的值可以赋给指针变量，同类型可以直接赋值，不同类型可通过强制类型转换，所以③是正确的。

答案：③

（8）设有定义：int a[10],*p=a+6,*q=a;，则下列运算哪种是错误的（ ）。

① p-q ② p+3 ③ p+q ④ p>q

解答：指向同一个数组的两个指针变量可以相减，其值是两个指针之间的元素个数。指向同一个数组的两个指针变量也可以比较，指向前面元素的指针“小于”指向后面元素的指针。指向数组元素的指针变量可以加减一个整型数c，加c后指向其后面的第c个元素，减c后指向其前面的第c个元素。但指向同一个数组的两个指针变量进行加法运算没有意义。

答案：③

（9）C语言中，数组名代表（ ）。

① 数组全部元素的值 ② 数组首地址 ③ 数组第一个元素的值 ④ 数组元素的个数 解答：C语言规定，数组名代表数组的首地址。 答案：②

（10）若有如下定义，则值为4的表达式是（ ）。

int a[12]={1,2,3,4,5,6,7,8,9,10,11,12}; char c=’a’,d,g;

① a[g-c] ② a[4] ③ a[’d’-’c’] ④ a[’d’-c]

解答：值为4的数组元素的下标为3，所以②是错误的，g-c的值不确定，’d’-’c’的值为1，只有’d’-c的值为3，所以④是正确的。

答案：④ （11）设有定义：char s[12]=\则printf(\的输出结果是（ ）。

① 6 ② 7 ③ 11 ④ 12

解答：函数strlen()的功能是返回字符串中第一个’\\0’之前的字符个数，所以输出结果为6。

答案：①

（12）语句printf(\的输出结果是（ ）。

① 11 ② 10 ③ 9 ④ 8 解答：字符串中的“\\n”、“\\1”和“\\\\”都是转义字符，都表示一个字符，所以字符串中的字符个数为9。

答案：③

75

（13）设有定义：int t[3][2];，能正确表示t数组元素地址的表达式是（ ）。

① &t[3][2] ② t[3] ③ t[1] ④ *t[2]

解答：C语言中，数组元素的下标从0开始，所以①和②是错误的，④表示数组元素a[2][0],③表示第二行的首地址，所以③是正确的。

答案：③

（14）语句strcat(strcpy(str1,str2),str3);的功能是（ ）。

① 将字符串str1复制到字符串str2中后再连接到字符串str3之后。 ② 将字符串str1连接到字符串str2中后再复制到字符串str3之后。

③ 将字符串str2复制到字符串str1后再将字符串str3连接到字符串str1之后。 ④ 将字符串str2连接到字符串str1后再将字符串str1复制到字符串str3中。 解答：先执行strcpy(str1,str2)，即将字符串str2复制到字符串str1中，再执行strcat(str1,str3)，即将字符串str3连接到字符串str1之后。

答案：③

（15）若有如下定义，则正确的叙述为（ ）。

char x[]=\

char y[]={’a’,’b’,’c’,’d’,’e’,’f’,’g’};

① 数组x和数组y等价 ② 数组x和数组y的长度相同

③ 数组x的长度大于数组y的长度 ④ 数组y的长度大于数组x的长度

解答：char y[]={’a’,’b’,’c’,’d’,’e’,’f’,’g’, ’\\0’};等价于：char x[]=\，所以③是正确的。

答案：③

2．程序分析题

（1）下列程序的运行结果是 main()

{ int a[3][3]={{1,2},{3,4},{5,6}}; int i,j,s=0; for(i=0;i<3;i++) for(j=0;j<=i;j++) s+=a[i][j]; printf(\ }

解答：此程序完成的功能是计算3×3矩阵的下三角阵（包括主对角线元素）元素和，运行结果是1+3+4+5+6，即19。

答案：19

（2）下列程序的运行结果是 main()

{ int i,j,k,n[3];

for(i=0;i<3;i++) n[i]=0; k=2;

for(i=0;i

printf(\

解答：当i=0时，n[0]=n[0]+1=1,n[1]=n[0]+1=2。

76

当i=１时，n[0]=n[１]+1=３,n[1]=n[１]+1=３。 答案：3

（3）下列程序的运行结果是 main()

{ int a[]={2,4,6,8,10}; int y=1,x,*p; p=&a[1];

for(x=0;x<3;x++) y+=*(p+x);

printf(\

解答：程序的功能是把数组a中下标为１、２和３的元素值累加到变量y上，即： y=1+4+6+8=19。 答案：19

（4）下列程序的运行结果是 main() { int i,c;

char num[][4]={\ for(i=0;i<4;i++)

{ c=num[0][i]+num[1][i]-2*’A’; printf(\ } } 解答：程序的功能是从左向右依次输出两个字符串对应字符的ASCII码之和与130的差值。

答案：2 5 5 8

（5）下列程序的运行结果是 main()

{ char a[]=\ int i,j,k;

for(i=0;i<5;i++) { printf(\

for(j=0;j

解答：此程序的功能是输出５行“*”号，每行有５个“*”，且从上到下每行向右挫一列。

答案： ***** ***** ***** ***** *****

（6）下列程序的功能是

77

main()

{ int i,a[10],*p=&a[9];

for(i=0;i<10;i++) scanf(\ for(;p>=a;p--) printf(\ }

答案：该程序把从键盘输入的10个整型数按相反的顺序输出。 （7）下列程序的运行结果是 main()

{ char ch[2][5]={\ int i,j,s;

for(i=0;i<2;i++) p[i]=ch[i]; for(i=0;i<2;i++) { s=0;

for(j=0;ch[i][j]!=’\\0’;j++) s=s*10+ch[i][j]-’0’; printf(\ } }

解答：程序的功能是把数字串转换成对应的数值。 答案：6937 8254

（8）下列程序的运行结果是 #include \ main()

{ int i,k,a[10],p[3]; k=5;

for ( i=0;i<10;i++) a[i]=i;

for(i=0;i<3;i++) p[i]=a[i*(i+1)]; for( i=0;i<3;i++) k+=p[i]*2;

printf(\ }

解答：由于k=5+(p[0]+p[1]+p[2])*2，且p[i]=a[i*(i+1)]=i*(i+1)，所以k的值为 5+(0+2+6)*2=21。 答案：21

（9）下列程序的运行结果是 #include \ main( )

{ int a=2,*p,**pp; pp=&p; p=&a; a++;

printf(\ }

78

解答：由于p指向a,pp又指向p,所以a、*p和**pp等价，其值都为３。 答案：3，3，3

（10）下列程序的运行结果是 main( )

{ int a[6],i;

for(i=0;i<6;i++)

{ a[i]=9*(i-2+4*(i>3))%5; printf(\ } }

解答：程序的功能是：i的值从０到５，依次输出表达式9*(i-2+4*(i>3))%5的值。 答案：-3 –4 0 4 4 3

3. 程序填空题(在下列程序的 处填上正确的内容,使程序完整) （1）下列程序的功能是输出数组s中最大元素的下标。 main() { int k,i;

int s[]={3,-8,7,2,-1,4}; for(i=0,k=i;i<6;i++)

if(s[i]>s[k]) ① ; printf(\ }

解答：程序输出的是最大元素的下标，所以，应将i值赋给k，即k=i。 答案：① k=i

（2）下列程序的功能是将一个字符串str的内容颠倒过来。 #include \ main()

{ int i,j,k;

char str[]=\

for(i=0,j= ② ;i

解答：由于C语言中数组元素的下标从0开始，所以j的值应为字符串长度减1，即strlen(str)-1。

答案：② strlen(str)-1

（3）下列程序的功能是把输入的十进制长整型数以十六进制数的形式输出。 main()

{ char b[]=\ int c[64],d,i=0,base=16; long n;

scanf(\ do

{c[i]= ③ ;i++;n=n/base; }while(n!=0); for(--i;i>=0;--i)

{ d=c[i];printf(\

79

}

解答：进制转换的算法是除以基数取余，所以应填nose。 答案：③ nose （4）下列程序的功能是从键盘输入若干个字符(以回车键作为结束)组成一个字符串存入一个字符数组，然后输出该数组中的字符串。

#include \ main()

{ char str[81],*ptr; int i;

for(i=0;i<80;i++) { str[i]=getchar();

if(str[i]==’\\n’) break; }

str[i]= ④ ; ptr=str;

while(*ptr) putchar( ⑤ ); }

解答：根据while(*ptr)可知，字符串末尾应有’\\0’，所以第一个空应填’\\0’。当ptr所指向的字符不为’\\0’时，将其输出，并且使ptr指向下一个字符，所以第二个空应填*ptr++。

答案：④ ’\\0’ ⑤ *ptr++

（5）下列程序的功能是将数组a的元素按行求和并存储到数组s中。 main()

{ int s[3]={0};

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

解答：根据题意，应将第i行累加到数组元素s[i]中。程序中的外循环次数是行数，内循环次数是列数，所以应填s[i]+=a[i][j](或s[i]=s[i]+a[i][j])。

答案：⑥ s[i]+=a[i][j](或s[i]=s[i]+a[i][j]) 4. 程序改错题(下列每小题有一个错误,找出并改正) （1）下列程序的功能是输入一个字符串，然后再输出。 main()

{ char a[20]; int i=0;

scanf(\

while(a[i]) printf(\ }

解答：使用scanf()函数时，输入项是地址，数组名本身就是地址，对数组名进行取地址运算没有意义。

80

答案：错误行：scanf(\修改为：scanf(\

（2）下列程序的功能是复制字符串a 到b中。 main()

{ char *str1=a,*str2,a[20]=\ str2=b;

while(*str2++=*str1++); } 解答：程序中用数组名a初始化指针变量str1,但此时数组a还没有定义，C语言规定，变量或数组必须先定义后使用，所以，必须先定义数组a,然后再定义指针变量str1,并用a对其初始化。

答案：

错误行：char *str1=a,*str2,a[20]=\修改为：char a[20]=\（3）下列程序的功能是统计字符串中空格数。 #include \ main()

{ int num=0;

char a[81],*str=a,ch; gets(a);

while((ch=*str++)!=’\\0’) if(ch=’ ’) num++; printf(\ } 解答：“=”是赋值运算符，程序中进行条件判断应使用关系运算符“==”。 答案：错误行：if(ch=’ ’) num++; 修改为：if(ch==’ ’) num++; （4）下列程序的功能是将字符串str中小写字母的个数、大写字母的个数和数字字符的个数分别存入a[0]、a[1]和a[2]中。

#include \ main()

{ char str[80]; int a[3],i=0; gets(str);

for(;str[i]!=’\\0’;i++)

if(str[i]>= ’a’&&str[i]<=’z’) a[0]++;

else if(str[i]>= ’A’&&str[i]<= ’Z’) a[1]++; else if(str[i]>= ’0’&&str[i]<= ’9’) a[2]++; for(i=0;i<3;i++)

printf(\ }

解答：数组a在定义时没有初始化，所以数组元素的初始值是随机的，因此，得到的统计结果不正确。

答案：错误行：int a[3],i=0; 修改为：int a[3]={0},i=0; （5）下列程序的功能是计算3×3矩阵的主对角线元素之和。 main()

81

{ int i,a[3][3]={1,2,3,4,5,6,7,8,9},sum=0; for(i=1;i<=3;i++) sum+=a[i][i]; printf(\ }

解答：C语言中数组元素的下标是从0开始的，所以循环变量i的取值应该是0到2。 答案：

错误行：将语句for(i=1;i<=3;i++) sum+=a[i][i]; 修改为：for(i=0;i<3;i++) sum+=a[i][i]; 5. 程序设计题

（1）输入10个整型数存入一维数组，输出值和下标都为奇数的元素个数。 解答： main()

{ int a[10],i,num=0;

printf(\ for(i=0;i<10;i++) scanf(\ for(i=0;i<10;i++)

if(i%2==1&&a[i]%2==1) num++; printf(\ }

（2）从键盘输入任意10个数并存放到数组中，然后计算它们的平均值，找出其中的最大数和最小数，并显示结果。

解答： main()

{ float a[10],ave=0,max,min; int i;

printf(\ for(i=0;i<10;i++) scanf(\ max=a[0];min=a[0]; for(i=0;i<10;i++) { ave+=a[i];

if(maxa[i]) min=a[i]; }

ave/=10;

printf(\}

（3）有5个学生，每个学生有四门课程，将有不及格课程的学生成绩输出。 解答： main()

{ int a[5][4]={{78,87,93,65}, {66,57,70,86}, {69,99,76,76},

82

{78,59,87,90}, {90,67,97,87}}; int i,j,k;

for(i=0;i<5;i++) for(j=0;j<4;j++) if(a[i][j]<60)

{ printf(\ for(k=0;k<4;k++)

printf(\ printf(\ break; } }

（4）已知两个升序序列，将它们合并成一个升序序列并输出。

解答：用数组a、b分别存放两个已知的升序序列，然后用下列方法将数组a、b中的元素逐个插入到数组c中。

?a[i]c[k]???b[j]a[i]?b[j]a[i]?b[j]

其中i、j、k的初值都为0，插入后k的值加1，i或j的值加1。 main()

{ int a[4]={1,3,5,7}; int b[5]={2,4,6,8,10}; int c[20],i=0,j=0,k=0; while(i<4&&j<5)

if(a[i]

printf(\ printf(\}

（5）从键盘上输入一个字符串，统计字符串中的字符个数。不许使用求字符串长度函数strlen()。 解答：

#include \main()

{ char str[81],*p=str; int num=0;

printf(\ gets(str);

while(*p++) num++;

printf(\

83

}

（6）输入一个字符串存入数组a，对字符串中的每个字符用加3的方法加密并存入数组b，再对b中的字符串解密存入数组c，最后依次输出数组a、b、c中的字符串。

解答：

#include \main()

{ char a[81],b[81],c[81]; char *pa=a,*pb=b,*pc=c; printf(\ gets(a);

while(*pa) {*pb=*pa+3; pa++;pb++;} *pb='\\0'; pb=b;

while(*pb) {*pc=*pb-3; pb++;pc++;} *pc='\\0';

printf(\ printf(\ printf(\}

（7）输入一个字符串，输出每个大写英文字母出现的次数。

解答：定义一个有26个元素的一维整型数组num，依次用来存放各个大写英文字母出现的个数。由于各大写英文字母的ASCII码与'A'的ASCII码的差，正好是用来存放该大写英文字母个数的数组元素的下标，所以，若当前字符*p为大写英文字母，则执行num[*p-'A']++即可使指定的数组元素值加1。

#include \main()

{ char str[81],*p=str; int num[26]={0},i;

printf(\ gets(str); while(*p)

{ if(*p>='A'&&*p<='Z') num[*p-'A']++; p++; }

for(i='A';i<='Z';i++) printf(\ printf(\ for(i=0;i<26;i++)

printf(\ printf(\}

（8）把从键盘输入的字符串逆置存放并输出。

解答：定义两个字符指针变量p和q，分别指向第一个字符和最后一个字符，交换p和q指向的字符，然后 p指向下一个字符，q指向前一个字符，再交换p和q指向的字符，如

84

此下去，直到p>=q为止。

#include \main()

{ char str[81],*p,*q,ch;

printf(\ gets(str); p=str;q=p; while(*q) q++; q--;

while(p

（9）输出4×4阶矩阵的主次对角线元素之和。

解答：矩阵主对角线上的元素，其行标和列标相等，矩阵次对角线上的元素，其行标与列标之和为3，用二维数组a[4][4]来表示4×4阶矩，所以，对满足行标和列标相等或行标与列标之和为3的二维数组元素求和即可。

main()

{ int a[4][4],i,j,sum=0;

printf(\ for(i=0;i<4;i++) for(j=0;j<4;j++)

scanf(\ for(i=0;i<4;i++) for(j=0;j<4;j++) if(i==j||i+j==3) sum+=a[i][j];

printf(\}

（10）统计一个英文句子中含有英文单词的个数，单词之间用空格隔开。

解答：单词的个数可以由空格出现的次数决定(连续的若干空格作为出现一次空格，一行开头的空格不统计在内)。如果当前字符不是空格，而它前面的字符是空格，则表示新单词开始，此时计数器加1。如果当前字符和它前面的字符都不是空格，则意味着仍然是原来单词的继续，计数器不能加1。前一个字符是否为空格，可以用一个变量word来标识，若word=0，则表示前一个字符为空格，若word=1，则表示前一个字符不为空格。

#include \main()

{ char str[81],*p=str; int num=0,word=0;

printf(\ gets(str); while(*p)

{ if(*p==' ') word=0; else if(word==0)

{ num++; word=1;}

85

p++; }

printf(\}

（11）从键盘上输入四个字符串(长度小于80)，对其进行升序排序并输出。

解答：利用选择排序法进行排序，用strcmp()函数进行比较，用strcpy()函数进行交换。

#include \#include \main()

{ char str[4][81],temp[81]; int i,j;

printf(\ for(i=0;i<4;i++) gets(str[i]); for(i=0;i<3;i++) for(j=i+1;j<4;j++)

if(strcmp(str[i],str[j])>0) { strcpy(temp,str[i]); strcpy(str[i],str[j]); strcpy(str[j],temp); }

printf(\ for(i=0;i<4;i++) puts(str[i]); }

（12）已知一个排好序的数组，输入一个数，要求按原来排序的规律将它插入到数组中。 解答：从数组的最后一个元素开始，逐个进行输入数和数组元素值的比较，若输入数小于数组元素值（假设原来升序排序），则数组元素值后移一个位置，否则将输入数存入当前数组元素的后一个元素。

main()

{ int a[10]={1,3,5,7,9,11},n=6,i,num; printf(\ scanf(\ i=n-1;

while(a[i]>num&&i>=0) {a[i+1]=a[i];i--;} a[i+1]=num;

printf(\ for(i=0;i<=n;i++) printf(\ printf(\}

（13）编写程序，实现两个字符串的比较。不许使用字符串比较函数strcmp()。

86

for(i=0;i

#include \#include \main()

{ int a[10]={0},len,i; char ch[81]; gets(ch);

len=strlen(ch); for(i=0;i

if(ch[i]>= '0'&&ch[i]<='9') a[ch[i]-'0']++; for(i=0;i<10;i++)

printf(\} （4）

#define N 5 main()

{ int a[N][N],i,j,t; for(i=0;i

scanf(\ for(i=0;i

{ t=a[i][i];a[i][i]=a[i][N-i-1]; a[i][N-1-i]=t;} for(i=0;i

printf(\ printf(\ } } （5）

#define M 3 #define N 4 main()

{ int a[M][N],i,j,k=0,b[M*N]; for(i=0;i

scanf(\ for(i=0;i

92

4.8 实验题目参考答案

（1）

#define N 10 main()

{ int a[N],i,j,t;

for(i=0;i

{ while(i0) i++; while(i

if (i

for(i=0;i

#define N 10

#include \main()

{ int a[N],i,j,t,m; scanf(\ m=m%N;

for(i=0;i

for(j=N-1;j>0;j--) a[j]=a[j-1]; a[0]=t; }

for(i=0;i

printf(\} （3） main()

{ float a[7][6]={0}; int i,j;

for(i=0;i<5;i++) { for(j=0;j<4;j++)

{ scanf(\ a[i][4]+=a[i][j]; a[5][j]+=a[i][j]; }

a[i][5]=a[i][4]/4; }

for(i=0;i<4;i++)

93

a[6][i]=a[5][i]/5; for(i=0;i<7;i++) { for(j=0;j<6;j++)

printf(\ printf(\ } } （4）

#define N 4 main()

{ int a[N][N],i,j,t; for(i=0;i

scanf(\ for(i=0;ia[j][j])

{ t=a[i][i];a[i][i]=a[j][j];a[j][j]=t;} for(i=0;i

printf(\ printf(\ } } （5） main()

{ int a[4][4],i,j,k,t,maxi,maxj; for(i=0;i<4;i++) for(j=0;j<4;j++)

scanf(\ for(i=0;i<4;i++) { maxi=i;maxj=i; for(j=0;j<4;j++) for(k=0;k<4;k++)

{ if(j==k&&j

if(a[maxi][maxj]>a[j][k]) {maxi=j;maxj=k;} }

t=a[i][i];a[i][i]=a[maxi][maxj]; a[maxi][maxj]=t; }

for(i=0;i<4;i++) { for(j=0;j<4;j++)

printf(\ printf(\ }

94

} （6）

#define N 4 main()

{ int a[N][N],i,j,s=0,max; for(i=0;i

scanf(\ for(i=0;i

if(max

for(i=0;i<4;i++) { for(j=0;j<4;j++)

printf(\ printf(\ }

printf(\} （7）

#include \#include \main()

{ char str[81];int i,j,t,l,k; gets(str); l=strlen(str); for(i=0;i

{ for(j=i+1,k=i;j

if(str[i]==str[j]) str[j]='\\0';

else if (str[j]!='\\0'&&str[k]>str[j]) k=j; if (k!=i) { t=str[k];str[k]=str[i];str[i]=t;} }

for(j=0,i=0;i

if(str[i]!='\\0') str[j++]=str[i]; str[j]='\\0'; puts(str); } （8）

#include \#include \main()

{ char str[81];

95

int t,i,j,cc; gets(str);

for(i=0,j=0;str[i];i++)

{ t=str[i]>='a'&& str[i]<='f'|| str[i]>='A'&& str[i]<='F'; if(str[i]>='0'&& str[i]<='9'||t) str[j++]=str[i]; }

str[j]='\\0'; t=0;

for(i=0;str[i]!=0;i++)

{ if(str[i]>='0'&& str[i]<='9') cc=48;

else if(str[i]>='a'&& str[i]<='f') cc=87; else cc=55;

t=t*16+str[i]-cc; }

printf(\}

4.9思考题参考答案

（1）答：若对数组初始化，则定义二维数组时第一维的长度可以省略，但第二维的长度不能省略。因为系统无法通过所提供的初始值确定其每列元素个数。而省略第一维长度时，系统可根据初始列表中值的个数和第二维的长度计算出所省略的第一维长度，具体计算方法为：第一维长度=?列表中值的个数/第二维的长度?。

（2）答：一维数组定义时，[]内的数据是规定数组的元素总个数，要求必须为常量表达式；引用数组元素时，[]内数据的为使用元素在数组内的序号，可以为各种表达式，要求表达式值的范围为0至元素总个数-1之间。 （3）答：利用q引用数组元素a[i][j]的方式有三种：q[i][j]、（q[i]+j）*和*(*(q+i)+j)。 （4）答：利用p引用数组元素a[i][j]的方式有三种：p[i][j]、（p[i]+j）*和*(*(p+i)+j)。 （5）答：第一种定义方式是用字符数组处理字符串，第二种定义方式是用字符指针处理字符串，其存储方式如图4.2所示。由此可知，第一种定义方式定义了一个等长的二维字符数组，第二种定义方式相当于定义了一个不等长的二维字符数组，每行宽度取决于具体字符串的长度。另外，系统为第一种定义方式分配的存储空间是连续的，但第二种定义方式的字符串之间则不一定连续。因此，相比于二维字符数组，指针数组有明显的优点，一是指针数组中不同元素所指的字符串不必限制长度，二是对字符串的处理是通过指针进行的，效率比下标方式要高。 但是二维字符数组却可以通过下标很方便的修改某一元素的值，而指针数组却不容易实现。 a[0] g a i n \\0 \\0 \\0 \\0 a[0] g a i n \\0 a[1] m u c h \\0 \\0 \\0 \\0 a[1] m u c h \\0 a[2] a[2] s t r o n g \\0 \\0 s t r o n g \\0 字符数组a的空间分配情况 （b）字符指针数组 (a) a的空间分配情况 图4.2 两种定义的空间分配情况示意图

96

本文来源：https://www.bwwdw.com/article/fwgo.html