作业本 - 《C程序设计》答案

第七部分 函 数

一、选择题（共20分，每题1分）

1．以下正确的函数形式是____D_ 。

A．double fun(int x,int y) B． fun(int x,y)

{ z=x+y; return z; } { int z; return z; } C．fun(x,y) D．double fun(int x,int y)

{ int x,y; double z; z=x+y; return z; } { double z; z=x+y; return z; }

2．C语言中，简单变量做参数.以下正确的说法是_____A__ 。

A． 实参和与其对应的形参各占用独立的存储单元 B． 实参和与其对应的形参共占用一个存储单元

C． 只有当实参和与其对应的形参同名时才共占用存储单元 D． 形参是虚拟的，不占用存储单元

3．若调用一个有返回类型的函数，且此函数中没有return语句，则该函数____D_______。

A．没有返回值 B．返回若干个系统默认值 C．能返回一个用户所希望的函数值 D．返回一个不确定的值 4．在C语言中，函数的数据类型是指_____A__ 。

A．函数返回值的数据类型 B．函数形参的数据类型 C．调用该函数时的实参的数据类型 D．任意指定的数据类型 5．以下不正确的说法是______A 。

A． 定义函数时，形参的类型说明可以放在函数体内 B． return后边的值不能为表达式

C． 如果函数值的类型与返回值不一致，以函数值类型为准 D． 如果形参与其实参的类型不一致，以形参类型为准

6．C语言规定，简单变量做实参时，它和对应形参之间的数据传递方式是____B__ 。

A．地址传递 B．单向值传递

C．由实参传给形参，再由形参传回给实参 D．由用户指定传递方式 7．C语言规定，函数返回值的类型是由 D_ 。

A．return语句中的表达式类型所决定 B．调用该函数时的主调函数类型所决定 C．调用该函数时系统临时决定 D．在定义该函数时所指定的函数类型所决定 8．下面函数调用语句含有实参的个数为_____ B 。

func((exp1,exp2),(exp3,exp4,exp5));

A．1 B．2 C．4 D．5 9．C语言中，函数调用不可以 D 。

A．出现在执行语句中 B．出现在一个表达式中 C．做为一个函数的实参 D．做为一个函数的形参 10．以下正确的描述是___ B__ 。

A． 函数的定义可以嵌套，但函数的调用不可以嵌套 B． 函数的定义不可以嵌套，但函数的调数用可以嵌套 C． 函数的定义和函数的调用均不可以嵌套 D． 函数的定义和函数的调用均可以嵌套

11．若有数组名作为函数调用的实参，传递给形参的是____ A_ 。

A．数组的首地址 B．数组第一个元素的值 C．数组中全部元素的值 D．数组元素的个数

12．如果在一个函数中的复合语句中定义了一个变量，则该变量___ A_ 。

A．只在该复合语句中有效 B．在该函数中有效 C．在本程序范围内均有效 D．为非法变量 13．以下不正确的说法是___D__ 。

A． 在不同函数中可以使用相同名字的变量 B． 形式参数是局部变量

C． 在函数内定义的变量只在本函数范围内有效

D． 在函数内的复合语句中定义的变量在本函数范围内有效

14．凡是函数中未指定存储类别的局部变量，其隐含的存储类别为____ A_ 。

A．自动（auto） B．静态(static) C．外部(extern) D．寄存器(register) 15．已有数组定义int a[3][4]; 和f函数调用语句f(a); ，则在f函数的说明中，对形参数组array

的错误定义方式为____B_ 。（A和D语法虽正确，千万别用） A．f(int array[][6]) B．f(int array[3][]) C．f(int array[][4]) D．f(int array[2][5]) 16．以下正确的说法是____C_ 。

A． 定义函数时，形参的类型说明可以放在函数体内 B． return后边的值不能为表达式

C． 如果函数值的类型与返回值类型不一致，以函数值类型为准 D． 如果形参与实参的类型不一致，以实参类型为准

17．如果程序中有static char c; 则编译程序会对其自动设置初值为____ C_ 。（ASCII码为0）

A．“\\n” B．’\\n’ C．0 D．“\\0” 18．以下程序有语法性错误，有关错误原因的正确说法是____ C_ 。 void main() { int G=5,k; void prt_char(); ? ? k=prt_char(G); ? ? }

A． 语句void prt_char();有错，它是函数调用语句，不能用void说明 B． 变量名不能使用大写字母

C． 函数说明和函数调用语句之间有矛盾 D． 函数名不能使用下划线

19．在一个void类型函数的定义中，函数体中有return; 语句，该语句____ B__ 。

1

A．是错的 C．在执行时不予理睬 20．以下不正确的描述是_____D 。

A．在函数外部定义的变量是全局变量 C．函数的形参是局部变量

B．表示向主调函数返回（程序控制） D．在执行时会中断程序运行 B．在函数内部定义的变量是局部变量 D．局部变量不能与全局变量同名

二、填空题（共40分，每题2.5分）

1．以下程序的运行结果是

#include ”stdio.h”

void add(int x,int y,int z) { z=x+y;x=x*x;y=y*y;

printf(“(2)x=%d y=%d z=%d\\n”,x,y,z); }

void main( )

{ int x=2,y=3,z=0;

printf(“(1)x=%d y=%d z=%d\\n”,x,y,z); add(x,y,z);

printf(“(3)x=%d y=%d z=%d\\n”,x,y,z); }

2．若输入一个整数30，以下程序的运行结果是

# include “stdio.h” int pr(int n)

{ int i,yes=1;

for(i=2;i

}

void main() { int m,k;

scanf(\

for(k=3;k

printf(\

}

3．若输入的值是-125，以下程序的运行结果是

2

#include”stdio.h” #include”math.h” void fun(int n) { int k,r;

for(k=2;k<=sqrt(n);k++) { r=n%k;

while(r==0)

{ printf(“%d”,k);

n=n/k;

if(n>1) printf(“*”); r=n%k; } }

if(n!=1) printf(“%d\\n”,n); }

void main( ) { int n;

scanf(“%d”,&n); printf(“%d=”,n); if(n<0)

printf(“-“); n=fabs(n); fun(n); }

4．函数gongy 的作用是求正整数num1和 num2的最大公约数，并返回该值。请填空

int gongy(int num1,int num2) { int temp,a,b; if(num1 num2)

{ temp=num1; num1=num2; num2=temp; } a=num1;b=num2;

while( )

{ temp=a%b; a=b; b=temp; } return(a); }

3

5．若输入一个整数10，以下程序的运行结果是

#include”stdio.h” int sub(int a) { int c; c=a%2; return c; }

void main( )

{ int a,e[10],c,i=0;

printf(“输入一整数\\n”); scanf(“%d”,&a); while(a!=0) { c=sub(a);

a=a/2; e[i]=c; i++; }

for(;i>0;i--)

printf(“%d”,e[i-1]);

}

6．以下程序的运行结果是 #include ”stdio.h”

long fib(int g) { switch(g) { case 0: return 0; case 1: case 2: return 1; } return(fib(g-1)+fib(g-2)); } void main() { long k; k=fib(7); printf(“k=%d\\n”,k);

}

4

7．以下程序的运行结果是 #include ”stdio.h”

int sub(int n) { int a; if(n==1) return 1; a=n+sub(n-1); return(a); } void main() { int i=5; printf(“%d\\n”,sub(i)); }

8．以下程序的运行结果是 ＃include”stdio.h” int fact(int value) { if(value<0)

{printf(“FACT(-1):ERROR!\\n”);return(-1);} else if(value==1||value==0) return(1);

else return(value*fact(value-1));

}

void main()

{ printf(“FACT(5):%d\\n”,fact(5));

printf(“FACT(1):%d\\n”,fact(1)); fact(-5); }

9. 下面程序的功能是用递归的方法将一个整型数num的各位数字转换为对应的数字字符输出，请填空完成程序。

#include ”stdio.h” void convert(int n)

{ int j; j=n/10;

if( )

convert( )

putchar( ) }

5

void main() { int num;

scanf(“%d”,&num); if(num<0)

{ putchar(‘-‘);

num= ; }

convert(num); }

10．折半查找法的思路是：先确定待查元素的范围，将其分成两半，然后测试位于中间点元素的值，如果该待查元素的值大于中间点元素，就缩小待查范围，只测试中点之后的元素；反之，测试中间点之前的元素，测试方式同前。函数binary的作用是应用折半查找法从存有10个整数的a数组中对关键字m进行查找，若找到，返回下标值；反之，返回-1。请填空。 int binary(int a[10],int m) { int low=0,high=9,mid; while(low<=high)

{ mid=(low+high)/2;

if(m

else

if(m>a[mid])

else return(mid);} return(-1); }

11．函数del的作用是删除有序数组a中的指定元素x。调用语句为n=del(a,n,x);其中实参n为删除前数组元素的个数，赋值号左边的n为删除后数组元素的个数。已知数组中存在x且没有重复元素，请填空。

int del(int a[],int n,int x) { int p,i; p=0;

while(x>=a[p] && p

; n=n-1; return n; }

6

12．函数yanghui能够按以下形式构成一个杨辉三角形，请填空。

１ １１ １２１ １３３１ １４６４１ １5 10 10 5１

?????????? ＃define N 11

void yanghui(int a[][N]) { int i,j;

for(i=1;i

{ a[i][1]=1; a[i][i]=1;} for( ;i

for(j=2; ;j++)

a[i][j]= +a[i-1][j];

}

13．下面的函数index(char s[], char t[])检查字符串s中是否包含字符串t，若包含，则返回t

在s中的开始位置（下标值），否则返回-1。

index(char s[], char t[]) { int i,j,k；

for(i=0；s[i]!= '\\0'；i++ )

{ for(j=i,k=0； && s[j]==t[k]；j++,k++) ；

if( )

return (i)；

}

return(-1)； }

14．函数 squeez(char s[],char c) 将字符串ｓ中所出现的与变量ch中相同的字符删去。 # include “stdio.h”

void squeez(char s[],char c) ??? { int i,j;

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

if (s[i]!=c) ; s[j]='\\0'; }

7

void main()

{ char str[128],ch; gets(str); ch=getchar(); squeez(str,ch); puts(str); }

15．以下程序的运行结果是

#include “stdio.h” int n=1; void func()

{ static int x=4;

int y=10; x=x+2; n=n+10; y=y+n;

printf(“FUNC:x=- y=- n=-\\n”,x,y,n); }

void main()

{ static int x=5;int y;

y=n;

printf(“MAIN:x=- y=- n=-\\n”,x,y,n); func( );

printf(“MAIN:x=- y=- n=-\\n”,x,y,n); func(); }

16．以下程序的运行结果是

#include

#define MAX 10 int a[MAX],i; void sub2( )

{ int a[MAX],i,max; max=5;

for(i=0;i

a[i]=i;

}

8

void sub1( )

{ for(i=0;i

a[i]=i+i;

}

void sub3(int a[]) { int i;

for(i=0;i

printf(“%d”,a[i]);

printf(“\\n”);

}

void main( ) { sub1( ); sub3(a); sub2( );

sub3(a);}

三、编程题（共40分，每题8分）

1．已有变量定义和函数调用语句：int x=57; isprime(x);函数isprime()用来判断一个整型数是否

为素数，若是素数，函数返回1，否则返回0。请编写isprime函数。

2．以下函数p的功能是用递归方法计算x的n阶勒让德多项式的值。已有调用语句p(n,x);请编写p函数。递归公式如下：

1(n?0)??Px(x)??x(n?1)

?((2n?1)*x*P(x)?(n?1)*P(x))/n(n?1)n?1n?2? float p(int n,int x)

{ }

3．请编写函数void fun(int m，int k，int xx[])，该函数的功能是：将大于整数m且紧靠m的k个素

数存入xx所指的数组中。在main函数中输出这些数。

例如，若输入m=17，k=5，则应输出：19，23，29，31，37。

4．设有一数列，包含10个数，已按升序排好。现要求编一程序，它能够把从指定位置开始的n个数按逆序重新排列并输出新的完整数列。进行逆序处理时要求使用函数实现。

5．编写一个函数insert(s1,s2,ch)，实现在字符串s1中的指定字符ch位置处插入字符串s2。（如果ch不在s1中则函数返回0否则返回1, 如果ch出现多次，以第一次出现位置为准）

*6．编写一个函数实现：（1）将字符串str1和字符串str2合并；（2）合并后的字符串按其ASCII码值从小到大进行排序；（3）相同的字符在新字符串中只出现一次。

9

1.

int isprime(int n)/*此函数用于判别素数*/ for(i=0;i

{

int i;

int k=sqrt(n) for(i=2;i

break;

if(i>=k)

return 1; else

return 0; } 2.

float p(int n,int x) { if(n==0)

return 1; else if(n==1) return x; else

return

((2*n-1)*x*p(n-1,x)-(n-1)*p(n-2,x))/n; 3.

void fun(int m，int k，int xx[]) { int s=0;

for(m=m+1;k>0;m++) if(isprime(m))

{ xx[s++]=m; k--;}

}

void main() {

int i,k,m,a[100]; printf(\输入m:\scanf(\printf(\输入k:\scanf(\ fun(m,k,a);

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

4.

例如：原数列为2，4，6，8，10，12，14，16，18，20，如果求把从第4个数开始的5个数按逆序重新排列，则新数列为2，4，6，16，14，12，10，8，18，20）

void invert(int a[], int pos, int n) /*数列a,pos为指定位置，n为个数*/ { int i,t;

for(i=0;i

a[pos+i]=a[pos+n-1-i]; a[pos+n-1-i]=t; } }

#include \void main() {

int a[10],i,m,n;

printf(\请输入10个数:\

for(i=0;i<10;i++) scanf(\printf(\请输入开始位置(M)和位数

(N):\

scanf(\invert(a,m,n); for(i=0;i<10;i++)

printf(\printf(\

10

5.

int insert(char s1[],char s2[],char ch) { int i,j,k;

int pos=-1;

/*找到ch第一次出现位置 pos,s1的长度i*/ for(i=0;s1[i]!= '\\0';i++)

if(s1[i]==ch &&pos==-1) pos=i; 6.

/*字符串s1和字符串s2合并后放在s3中*/ void merge(char s1[],char s2[],char s3[]) { int i,j,k=0;

/* s1中字符逐个插入到s3, 如果s3中已存在则不插入,插入后仍保持s3有序 */ for(i=0;s1[i]!= '\\0';i++)

{ /*在s3中寻找>=s1[i]的字符*/

if(pos==-1) return 0;

if (s3[j]>=s1[i]) break; /*求出s2的长度j, 也可以用strlen(s2)*/ if(j==k||s3[j]>s1[i])

for(j=0;s2[j]!= '\\0';j++);

/*s1从pos开始的字符后移j个位置*/ { /* if(j>0)

for(m=k-1;m>=j;m--) for(k=i;k>=pos;k--) s3[m+1]=s3[m]; s1[k+j]=s1[k]; s3[j]=s1[i];

k++; /*插入s2*/

for(k=0;k

s1[pos+k]=s2[k]; /* s2 return 1; } { /*

if (s3[j]>=s2[i]) break; if(j==k||s3[j]>s2[i])

{ /* for(m=k-1;m>=j;m--) s3[m+1]=s3[m]; s3[j]=s2[i]; k++; }

s3[k]=}

11

for(j=0;j

/*都s1[i]

(j

插入到s3中j位置*/ } 中字符逐个插入到s3, 如果s3中已存在则不插入,插入后仍保持s3有序 */ '\\0';i++)

在s3中寻找>=s2[i]的字符*/

for(j=0;j

/*都s2[i]

(j

插入到s3中j位置*/ } '\\0'; for(i=0;s2[i]!=

第八部分 宏 定 义

一、选择题（共30分，每题2.5分）

1．在宏定义 #define PI 3.14159中，用宏名PI代替一个 D 。

A．常量 B．单精度数 C．双精度数 D．字符串 2．C语言的编译系统对宏命令的处理是 D 。

A． 在程序运行时进行的 B． 在程序连接时进行的

C． 和C程序中的其它语句同时进行编译的 D． 在对源程序中其它成份正式编译之前进行的 3．以下有关宏替换的叙述不正确的是 D 。

A．宏替换不占用运行时间 B．宏名无类型

C．宏替换只是字符替换 D．宏名必须用大写字母表示 4．以下叙述中不正确的是 C 。

A． 预处理命令行都必须以#号开始

B． 在程序中凡是以#号开始的语句行都是预处理命令行 C． C程序在执行过程中对预处理命令行进行处理 D． 以下是正确的宏定义

#define IBM_PC

5．以下叙述中正确的是 C 。

A． 在程序的一行上可以出现多个有效的预处理命令行 B． 使用带参的宏时，参数的类型应与宏定义时的一致 C． 宏替换不占用运行时间，只占编译时间 D． 在以下定义中CR是称为“宏名”的标识符

#define CR 045

6．若有宏定义： #define MOD(x,y) x%y 则执行以下语句后的输出为 B 。 int z,a=15,b=100; z=MOD(b,a); printf(“%d\\n”,z++);

A．11 B．10 C．6 D．宏定义不合法 7．用宏替代计算多项式4*x*x+3*x+2之值的函数f,正确的宏定义是 A 。

A．#define f(x) (4*(x)*(x)+3*(x)+2) B．#define f 4*x*x+3*x+2

C．#define f(a) (4*a*a+3*a+2) D．#define (4*a*a+3*a+2) f(a) 8．以下在任何情况下计算平方数时都不会引起二义性的宏定义是 D 。

A．#define POWER(x) x*x B．#define POWER(x) (x)*(x) C．#define POWER(x) (x*x) D．#define POWER(x) ((x)*(x))

12

9．对下面程序段，正确的判断是 B 。 #define A 3 #define B(a) ((A+1)*a) ? x=3*(A+B(7));

A． 程序错误，不许嵌套宏定义 B． x=93 C． x=21

D． 程序错误，宏定义不许有参数

10．在“文件包含”预处理语句的使用形式中，当#include后面的文件名用“ ”（双引号）括起时，

寻找被包含文件的方式是 B 。 A． 直接按系统设定的标准方式搜索目录

B． 先在源程序所在目录搜索，再按系统设定的标准方式搜索 C． 仅仅搜索源程序所在目录 D． 仅仅搜索当前目录

11．以下正确的描述是 C 。

A． C语言的预处理功能是指完成宏替换和包含文件的调用 B． 预处理指令只能位于C源程序文件的首部

C． 凡是C源程序中行首以“#”标识的控制行都是预处理指令 D． C语言的编译预处理就是对源程序进行初步的语法检查 12．C语言提供的预处理功能包括条件编译，其基本形式为： #XXX 标记符 程序段1 #else 程序段2 #endif

这里XXX可以是 D 。

A．define或include B．ifdef或include C．ifdef或ifndef或define D．ifdef或ifndef或if

二、填空题（共50分，每题5分）

1． (1) 设有以下宏定义： #define WIDTH 80 #define LENGTH WIDTH+40

则执行赋值语句：v=LENGTH*20; （v为int型变量）后，v的值是 880 。 (v=LENGTH*20; => v= WIDTH+40*20; => v= 80+40*20;) (2) 设有以下宏定义： #define MUL(z) (z)*(z)

13

则执行语句：printf(“%d\\n”,MUL(1+2)+3); 的结果是 12 。

MUL(1+2)+3 => (1+2)*(1+2)+3

2．以下程序的运行结果是 sum=10 。 #include “stdio.h” #define ADD(x) x+x void main() { int m=1,n=2,k=3; int sum=ADD(m+n)*k; printf(“sum=%d”,sum); }

ADD(m+n)*k => m+n+m+n*k

3．以下程序的运行结果是 12 。 #include #define FUDGE(y) 2.84+y #define PR(a) printf(“%d”,(int)(a)) #define PRINT1(a) PR(a); putchar(‘\\n’) void main() { int x=2; PRINT1(FUDGE(5)*x); }

4．以下程序的运行结果是 5 。 #include “stdio.h” #define DOUBLE(r) r*r void main() { int x=1,y=2,t; t=DOUBLE(x+y); printf(“%d\\n”,t); }

5．以下程序的输出结果是 1 2 3 ok! 。 #include “stdio.h” #define PR(a) printf(“%d\\t”,(int)(a)) #define PRINT(a) PR(a); printf(“ok!”) void main() { int i,a=1; for(i=0;i<3;i++) PRINT(a+i); printf(“\\n”); }

14

6．下面程序执行FOR循环时，j的初值是 3 ，终值是 0 。 #include “stdio.h” #define BOT (-2) #define TOP (BOT+5) #define PRI(arg) printf(“%d\\n”,arg) #define FOR(arg) for(;(arg);(arg)--) void main() { int i=BOT,j=TOP; FOR(j) switch(j) { case 1: PRI(i++); case 2: PRI(j); break; default: PRI(i); } }

7．下面程序的运行结果是 1 12 123 1234

TABLE 。

#include “stdio.h” #define PRI printf #define NL “\\n” #define D “%d” #define D1 D NL #define D2 D D NL #define D3 D D D NL #define D4 D D D D NL #define S “%s” void main() { int a,b,c,d; char string[]=“TABLE”; a=1; b=2; c=3; d=4; PRI(D1,a); PRI(D2,a,b); PRI(D3,a,b,c); PRI(D4,a,b,c,d);

15

PRI(S,string); }

8．设有以下程序，为使之正确运行，请填入应包含的命令行。 /* a.c */ #include #include “myfile.txt” void main() { try_me();} /* 函数调用 */ /* myfile.txt */ 注：try_me()函数在myfile.txt中有定义 void try_me() { char c; if((c=getchar())!=‘\\n’) try_me(); putchar(c); }

9．以下程序的运行结果是 c=2 。 #include “stdio.h” #define DEBUG void main() { int a=20,b=10,c; c=a/b; #ifndef DEBUG printf(“a=%o,b=%o,”,a,b); #endif printf(“c=%d\\n”,c); }

10．以下程序的输出结果为 c language 。 #include “stdio.h” #define LETTER 0 void main() { char str[20]=“C Language”,c;

int i=0;

while((c=str[i++])!=‘\\0’) { #if LETTER if(c>=‘a’&&c<=‘z’) c=c-32; #else if(c>=‘A’&&c<=‘Z’) c=c+32; #endif printf(“%c”,c);

16

}

}

三、编程题（共20分，每题10分）

1．输入两个整数，求它们相除的余数。用带参的宏来编程实现。

2．试定义一个带参的宏swap(x,y)，以实现两个整数之间的交换，并利用它将一维数组a和b的值

进行交换。

17

1.

#define MOD(x,y) ((x)%(y)) #include \void main() {

int a,b,c;

scanf(\,&a,&b); c=MOD(a,b);

printf(\,a,b,c); }

2.

#define swap2(x,y){int s=x;x=y;y=s;} #include

void main() { int a1[3]={1,2,3}; int a2[3]={11,12,13}; int i;

printf(\交换前 a1:\\n\); for (i=0;i<3;i++)

printf(\,a1[i]);

printf(\);

printf(\交换前 a2:\\n\); for (i=0;i<3;i++)

printf(\,a2[i]);

printf(\);

for(i=0;i<3;i++) { swap2(a1[i],a2[i]); }

printf(\交换后 a1:\\n\); for (i=0;i<3;i++)

printf(\,a1[i]);

printf(\);

printf(\交换后 a2:\\n\); for (i=0;i<3;i++)

printf(\,a2[i]);

printf(\); }

18

第九部分 指 针

一、选择题（共20分，每题1分）

1．若已定义：int *p,a;,则语句p＝&a；中的运算符“&”的含义是 D 。

A．位与运算 B．逻辑与运算 C．取指针内容 D．取变量地址 2．若有定义int a[10],*p=a; ，则p+5表示 A 。

A．元素a[5]的地址 B．元素a[5]的值 C．元素a[6]的地址 D．元素a[6]的值

3．若有定义int a[5],*p=a; ，则对a数组元素的正确引用是 D 。

A．*&a[5] B．a+2 C．*(p+5) D．*(a+2) 4．下列选项中正确的语句组是___D___。

A．char s[8]; s={\．char *s; s={\C．char s[8]; s=\．char *s; s=\

5．若有说明：int i, j=2，*p=&i; ，则能完成i=j赋值功能的语句是 B 。

A．i=*p; B．*p=j; C．i=&j; D．i=&p;

6．若有语句int *point,a=4;和point=&a;下面均代表地址的一组选项是 D 。

A．a,point,*&a B．&*a,&a,*point C．*&point,*point,&a D．&a,&*point ,point

7．若有定义：int a[2][3], 则对a数组的第i行j列元素地址的正确引用为 D 。

A.*(a[i]+j) B.(a+i) C.*(a+j) D.a[i]+j 8．有以下函数，该函数的返回值是 C 。

int fun(int *p) { return *p；}

A．不确定的值 B．形参p中存放的值 C．形参p所指存储单元中的值 D．形参p的地址值

9．若已定义：int a[ ]={0，1，2，3，4，5，6，7，8，9}，*p=a，i；

其中 0

A.a[p-a] B.*(&a[i]) C.p[i] D.a[10]

10．定义一个函数实现交换x和y的值，并将结果返回。能够实现此功能的是 C 。

A．void swapa(int x,int y) B．void swapb(int *x,int *y)

{ int temp； { int temp；

temp=x；x=y；y=temp； temp=x；x=y；y=temp； } }

C．void swapc(int *x,int *y) D．void swapd(int *x,int *y)

{ int temp； { int *temp；

temp=*x；*x=*y；*y=temp； temp=x；x=y；y=temp； } }

19

printf(\链表a的信息为：\\n\); output(a);

printf(\链表b的信息为 ：\\n\); output(b); c=del(a,b);

printf(\删除后的链表信息为 ：\\n\); output(c); return 0; }

45

3．用fread & fwrite

(二进制文件worker.dat事先必须存在！） #include #include struct worker{ long num; char name[20]; int age; int salary;

};

void main() {

FILE *fp1,*fp2; struct worker w;

fp1=fopen(\,\); if(fp1==NULL)

{ printf(\);

exit(0); }

fp2=fopen(\,\); if(fp2==NULL)

{ printf(\);

exit(0); }

while( fread(&w,sizeof(struct worker),1,fp1)==1) if (w.age<=40&&w.salary>=1000) {

if(fwrite(&w,sizeof(struct worker),1,fp2)!=1) { printf(\); break;

}

printf(\,w.num,w.name,w.age,w.salary);

} fclose(fp1); fclose(fp2); }

46

3．用fscanf & fprintf

(文本文件worker.txt事先必须存在！） #include #include struct worker{ long num; char name[20]; int age; int salary;

};

void main() {

FILE *fp1,*fp2; struct worker w;

fp1=fopen(\,\); if(fp1==NULL)

{ printf(\);

exit(0); }

fp2=fopen(\,\); if(fp2==NULL)

{ printf(\); exit(0);

}

while(fscanf(fp,\,&w.num,w.name,&w.age,&w.salary)==4) if (w.age<=40&&w.salary>=1000) { if(fprintf(fp,\,w.num,w.name,w.age,w.salary)!=4) {

printf(\); break;

}

printf(\,w.num,w.name,w.age,w.salary);

} fclose(fp1); fclose(fp2); }

47

4.

#include #include void main() {

char szText[9999]={0}; char szShow[9999]={0};

char szSub1[]=\,szSub2[]=\,szSub3[]=\; char ch;

int inQuotation=0,iIndex=0,i=0; /* inQuotation =1 注释在双引号里 不去掉*/ FILE *fp=fopen(\,\); if(fp==NULL) { printf(\); return;

}

ch=fgetc(fp); while(ch!=EOF) { szText[i++]=ch; ch=fgetc(fp);

}

szText[i]='\\0'; fclose(fp);

for(i=0;i<(int)strlen(szText);i++) { if(szText[i]=='\\\) /* 判断双引号*/ { inQuotation=(inQuotation+1)%2;

}

else if(!inQuotation) { if(strncmp(&szText[i],szSub1,strlen(szSub1))==0) // 单行注释 开始 { i+=strlen(szSub1); while(szText[i]) { if(szText[i]=='\\n') // 单行注释 结束

break;

48

}

}

i++;

else if(strncmp(&szText[i],szSub2,strlen(szSub2))==0) // 多行注释 开始 {

i+=strlen(szSub2); while(szText[i]) {

if(szText[i]=='*') {

if(strncmp(&szText[i],szSub3,strlen(szSub3))==0) {

i+=strlen(szSub3); break; } } i++; } } }

szShow[iIndex++]=szText[i]; }

szShow[iIndex]='\\0'; puts(szShow); }

例子

从文件中输入:

int i=1; //define integer int f=1; /* define float */

printf(\Quotation\Quotation

printf(\/* in Quotation */\/* not in Quotation */ f++;

运行结果： int i=1; int f=1;

printf(\Quotation\printf(\/* in Quotation */\f++;

49

// 多行注释 结束

11．若有以下定义和语句： int s[4][5],(*ps)[5]; ps=s;

则对s数组元素的正确引用形式是 C 。

A．ps+1 B．*(ps+3) C．ps[0][2] D．*(ps+1)+3 12．若有定义：int *p[3];，则以下叙述中正确的是 B 。

A．定义了一个基类型为int的指针变量p，该变量具有三个指针

B．定义了一个指针数组p，该数组含有三个元素，每个元素都是基类型为int的指针 C．定义了一个名为*p的整型数组，该数组含有三个int类型元素

D．定义了一个可指向一维数组的指针变量p，所指一维数组应具有三个int类型元素 13．说明语句 int (*p)( )； 的含义是 C 。

A．p是一个指向一维数组的指针变量 B．p是指针变量，指向一个整型数据

C．p是一个指向函数的指针，该函数的返回值是一个整型 D．以上都不对

14．设有说明int (*p)[4]；其中的标识符p是 C。

A．4个指向整型变量的指针变量 B．指向4个整型变量的函数指针

C．一个指向具有4个整型元素的一维数组的指针

D．具有4个指向整型变量的指针元素的一维指针数组 15．在说明语句：int *f( )；中，标识符f代表是 D 。

A．一个用于指向整型数据的指针变量 B．一个用于指向一维数组的行指针 C．一个用于指向函数的指针变量 D．个返回值为指针型的函数名 16．已知：char a[3][10]={\；

不能正确显示字符串\的语句是 C 。

A．printf(\； B．printf(\； C．printf(\； D．printf(\；

17．已知：int a[]={1,2,3,4}, y, *p=a；则执行语句y = (*++p)--；后,

数组a各元素的值变为___B__。

A．0,1,3,4 B．1,1,3,4 C．1,2,2,4 D．1,2,3,3 变量y的值是 B 。

A．1 B．2 C．3 D．4 18．不合法的main函数命令行参数表示形式是 C 。

A．main(int a，char *c[ ]) B．main(int arc，char **arv) C．main(int argc，char *argv) D．main(int argv，char *argc[ ]) 19．设有定义: char *cc[2]={“1234”,”5678”};则正确的叙述是 A 。

A．cc数组的两个元素中各自存放了字符串“1234”和“5678”的首地址 B．cc数组的两个元素分别存放的是含有4个字符的一维字符数组的首地址 C．cc是指针变量，它指向含有两个数组元素的字符型一维数组 D．cc数组元素的值分别是“1234”和“5678”

20．已有函数max(a,b),为了让函数指针变量p指向函数max正确的赋值方法是 A 。 A．p=max B．*p=max C．p=max(a,b) D．*p=max(a,b)

20

二、填空题（共50分，每题2.5分）

1．若有定义：int a[3][5],i,j;( 0≤i<3,0≤j<5),则数组元素可用以下五种形式引用：(1) a[i][j]、 (2) *(a[i]+j)、(3) *(*(a+i)+j )、(4) (*(a+i))[j]、 (5) *( &a[0][0] +5*i+j)

2．以下程序的运行结果是 6,2 。

#include “stdio.h” int func(int *a) { int b=2； b+= *a++； return(b)； }

void main( )

{ int a=2，res=2； res+= func(&a)；

printf(\，res,a)； }

3．以下程序的输出结果为 4,5,5 。 # include \

void f(int *x,int y)

{ int t; if(*x

{t=*x;*x=y;y=t;} } void main()

{ int a=4,b=3,c=5;

f(&a,b); f(&b,c); f(&c,a); printf(\}

4．以下程序的运行结果是 -1 (<0的值就行) 。

#include “stdio.h” #include “string.h” void main()

{ char *s1=\ char *s2=\ s1+=2;s2+=2;

printf(\ }

21

5．以下程序的运行结果是 rst+rst=xyzxyz 。

#include “stdio.h” char cchar(char ch)

{ if(ch>='A'&&ch<='Z')

ch=ch-'A'+'a'; return ch; }

void main()

{ char s[]=\

while(*p)

{ *p=cchar(*p);

p++; }

printf(\}

6．以下程序的运行结果是 5,4,3,2,1,6,7,8,9,10, 。

# include “stdio.h”

# define N 10 void func(int b[]，int n)

{ int *p=b,*t=b+n-1,tmp; for(;p

{ tmp=*p; *p=*t; *t=tmp; }

} void main()

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

for(p=a;p

}

7．以下程序的输出结果是 Afgd 。

#include “stdio.h” #include\void main( )

{ char *p1，*p2，str[50]=\； p1=\； p2=\； strcpy(str+1，p2+1)； strcpy(str+3，p1+3)； printf(\，str)； }

22

8．以下程序的输出结果为 0,1,2,3,5,6,7,8, 。 # include “stdio.h” void func(int *b，int n)

{ int *p,j=0; for(p=b;p

}

void main()

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

for(p=a;p

}

9．以下程序的运行结果是 1711717 。

#include “stdio.h” #include “string.h” fun(char *w,int n) { char t,*s1,*s2; s1=w; s2=w+n-1;

while(s1

void main()

{ char *p=\ fun(p,strlen(p)); puts(p); }

10．以下程序的运行结果是 6385 。

#include “stdio.h” void main( )

{ char ch[2][5]={ \，\，*p[2]；

int i，j，s=0； for(i=0；i<2；i++)

p[i]=ch[i]； for(i=0；i<2；i++)

for(j=0；p[i][j]> '\\0'；j+=2)

s=10*s+p[i][j]- '0'； printf(\，s)； }

23

11．以下程序运行时，从键盘输入abcdef 和ABCD ，

则运行结果是 _________abcdefABCD=10_________________ 。

# include \

int fun(char *a,char *b) { int num=0,n=0;

while (*(a+num)!= '\\0' ) num++; while (b[n])

{ *(a+num)= b[n]; num++;

n++;

}

return num;

} void main()

{ char s1[80]= \ gets(p1); gets(p2);

printf(\}

12．以下程序的输出结果为 ABCDBCDCDD 。

# include “stdio.h” void main()

{ char b[]=”ABCD”;

char *chp;

for(chp=b;*chp!=’\\0’;chp++) printf(“%s”,chp);

}

13. 以下程序的输出结果为 AEIM 。

# include “stdio.h” void main()

{ char *alpha[7]={\；

char **p； int i； p=alpha；

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

printf(\；

}

24

14．以下程序经编译和连接后生成可执行文件PROG.EXE，如果在此可执行文件所在目录的DOS提示符下键入：PROG AB CDEFGH IJKL<回车>，则输出结果为 IJKLCDEFGHAB 。

# include “stdio.h”

void main( int argc，char *argv[]) { while(--argc>0)

printf(\，argv[argc])；

}

15. mystrlen函数的功能是计算str所指字符串的长度，并作为函数值返回。int mystrlen(char *str) { int i；

for(i=0； *(str+i) != '\\0'；i++)

；

return ( i )； }

16. 以下程序判断整型数组是否“对称”（即顺读和倒读都一样，如: 1 2 3 3 2 1 # include \ # define N 10

void main()

{ int a[N],*p1=a,*p2;

for(p2=a;p2

scanf(“%d”,p2);

p2= a+N-1 ; while( p1

p1++; p2-- ;

}

if（p1

prinf(\ else

prinf(\

}

25

）。

17. 下面程序的功能是在字符串str中找出最大字符并放在第一个位置上，并将该字符前的原字符

往后顺序移动，如chyab变成ychan。

# include \void main()

{ char str[128],*p=str,*q,max; gets(p); max=*p;

while( *p!= '\\0' ) { if(max<=*p) { max=*p;

q=p

} p++; } p=q;

while( p>str ) { *p=*(p-1);

p-- }

*p=max; puts(p); }

18. 下面程序的功能是将两个字符串s1和s2连接起来。

#include \

char* conj(char *p1,char *p2) { char *p=p1;

while(*p1) p1++ ;

while(*p2){ *p1= *p2 ; p1++; p2++;} *p1='\\0';

return p ; }

void main()

{ char s1[80],s2[80]; gets(s1);

gets(s2); conj(s1,s2); puts(s1); }

26

19. 以下函数Remove_blank删除字符串中所有空格。

# include \Remove_blank(char *s) { int i, tmp;

char tmpstr[128];

for (i = 0, tmp = 0; s[i] != '\\0' ; i++) if(s[i] != ' ')

tmpstr[ tmp++ ]=string[i]; tmpstr[tmp]= '\\0' ; strcpy(s,tmpstr);

}

20．以下递归函数将n个整数的前面各数顺序向后移m个位置，最后m个数变成最前面的m个数。

void move(int array[],int n,int m) { int *p,array_end;

array_end= *(array+n-1) ; for(p=array+n-1;p>array;p--) *p=*(p-1);

*array= array_end ; m--; if(m>0)

move(array,n,m) ;

}

三、编程题（共30分，每题5分）

1．从键盘输入两个字符串a和b，要求不用strcat把b中的前五个字符连接到a中，如果b的长度

小于5，则把b的所有元素都连接到a中。试编程。

2．请编写函数fun，该函数的功能是将M行N列的二维数组中的数据，按列的顺序依次放到一维数

组中。在主函数中输入/输出数组。

3．请编一个的函数fun(char *s)，该函数（非递归）的功能是把字符串中的内容逆置。要求不得

使用C语言的字符串函数，在主函数中进行字符串的输入与输出。

例如：输入字符串为abcdefg，则调用该函数后，字符串中的内容为gfedcba。

4．设有一数列，包含10个数，已按升序排好。现要求编程实现从指定位置开始的n个数按逆序重

新排列并输出新的完整数列。进行逆序处理要求用指针方法。（例如：原数列为 2，4，6，8，10，12，14，16，18，20，

若要求把从第4个数开始的5个数按逆序重新排列，则得到的新数列为 2，4，6，16，14，12，10，8，18，20）

27

5．假定输入的字符串中只包含字母和*号。请编写函数fun，它的功能是：将字符串尾部的*号全部

删除，前面和中间的*号不删除。在主函数中输入、输出字符串。

例如，若字符串中的内容为****A*BC*DEF*G*******，删除后，字符串中的内容则应当是****A*BC*DEF*G。（不得使用C语言提供的字符串函数）

6．M个学生的成绩存放在score数组中，请编写函数，其功能是：将低于平均分的人数作为函数值

返回，将低于平均分的分数放在below所指的数组中。在主函数中输出人数和below数组。

2. 1.

#include

void strcat5(char *p1,char *p2) { int i=0;

while(*p1!='\\0')p1++; /*移到字符串最后*/ while(*p2!='\\0'&&i<5) /*拷贝字符到后面*/

{*p1=*p2;p1++;p2++;i++;}

*p1='\\0'; }

void main() {

char s1[80],s2[80]; gets(s1); gets(s2); strcat5(s1,s2); puts(s1); }

#include #define M 4 #define N 5

void Fun(int a[][N],int b[]); void main()

{ int a[M][N] = {1,2,3,4,5,

6,7,8,9,10, 11,12,13,14,15, 16,17,18,19,20};

int b[M*N]; int i,j; Fun(a,b);

printf(\); for(i=0;i

printf(\); for(i=0;i

void Fun(int a[][N],int b[]) {

int i=0,j=0; int *p=b;

for (j = 0; j < N; j++)

for (i = 0; i < M; i++) *p++=a[i][j]; }

for(j=0;j

printf(\,a[i][j]); printf(\);

28

3.

#include \ void fun(char *s) { char t,*s1,*s2; s1=s2=s; while(*s2!='\\0')s2++;

/*移到字符串最后*/

s2--; while(s1

}

}

void main() { char p[80]; gets(p); fun(p); puts(p); }

4.

#include \

void fun(int *p,int n,int start,int count) { int t,*p1,*p2; p1=p+start-1; p2=p+start+count-2;

while(p1

p1++;p2--;

}

}

void main() { int a[10]; int i,start,count;

printf(\请输入10个数:\\n\); for(i=0;i<10;i++)

scanf(\,&a[i]);

printf(\请输入起始位置:\\n\); scanf(\,&start); printf(\请输入个数:\\n\); scanf(\,&count);

if(start<1||start>10||count<1||count>10

||start+count-1>10) { printf(\起始位置或个数的范围错误!\\n\); return ;

}

fun(a,10,start,count); printf(\处理后的结果:\\n\); for(i=0;i<10;i++)

printf(\,a[i]);

}

29

5．

#include void fun(char *a) {

char *t; t=a;

while(*t!='\\0') t++;

t--; /*移到字符串最后*/ while(t>=a&&*t=='*')

t--; /*向前删除*/ *(t+1)='\\0';

}

void main() { char a[80]; gets(a); fun(a); if(*a!='\\0')

puts(a);

else puts(\变成空串了!\); }

6.

#include

int fun(int score[],int m,int below[]) { int *p,*q,k; float aver=0;

for(p=score;p

aver+=*p;

aver/=m;

q=below; k=0; for(p=score;p return k;

}

void main() { int a[10],b[10]; int i,k;

printf(\请输入10个学生的成绩:\\n\); for(i=0;i<10;i++)

scanf(\,&a[i]);

k=fun(a,10,b);

printf(\低于平均分的学生人数是:%d\\n\,k); printf(\低于平均分的成绩是:\\n\); for(i=0;i

printf(\,b[i]); }

30

第十部分 结构体

一、选择题（共24分，每题1.5分）

1．以下对结构体变量stu1中成员age的非法引用是 B 。

struct student { int age; int num; }stu1,*p=&stu1;

A．stu1.age B．student.age C．p->age D．(*p).age 2．有定义如下，则对于结构变量data的成员a的正确引用是 B 。

struct sk { int a；

float b； }data ,*p=&data；

A. data->a B. (*p).a C. p->data.a D. p.data.a (=>data.a, p->a)

3．以下scanf函数调用语句中对结构体变量成员的不正确引用是 D 。

struct pupil { char name[20]; int age; int sex; }pup[5],*p=pup;

E． scanf(\ B．scanf(\

C． scanf(\ D．scanf(\=> &p->age 4．根据如下定义： struct person{char name[9]； int age；}；

struct person class[10]={ \，17，\，19，\，18，\，16}； 能输出字母‘M’的语句是 D 。

A．prinft(\，class[3]. name)； B．printf(\，class[3].name[1])； C．prinft(\，class[2].name[1])； D．printf(\，class[2].name[0])； 5．设有以下说明语句： struct ex

{ int x；

float y； char z； }example；

则下面的叙述中不正确的是 B 。

A．struct是结构体类型的关键字 B．example是结构体类型名 C．x，y，z都是结构体成员名 D．struct ex是结构体类型名

31

6．定义一个结构体变量时，系统分配给它的内存大小是 A 。

A．各成员所需内存量的总和 B．成员中占内存量最大者所需内存容量 C．结构中第一个成员所需内存容量 D．结构中最后一个成员所需内存容量 7．C语言结构体类型变量在程序执行期间 A 。

A．所有成员一直驻留在内存中 B．只有一个成员驻留在内存中 C．部分成员驻留在内存中 D．没有成员驻留在内存中 8．若有以下定义，则不正确的引用是 D 。

struct student{int age;int num;};

struct student stu[3]={{1001,20},{1002,19},{1003,21}},*p=stu;

A．(p++)->num B．p++ C．(*p).num D．p=&stu.age 9．若有以下说明和语句，则下面表达式中的值为1002的是 B 。

struct student { int age;

int num;

}stu[3]={{1001,20},{1002,19},{1003,21}}，*p=stu;

A．(p++)->num B．(++p)->age C．(*p).num D．(*++p)->age 10．若有以下程序段：

struct dent { int n;

int *m; };

int a=1,b=2,c=3;

struct dent s[3]={{101,&a},{102,&b},{103,&c}}，*p=s; 则下面表达式中的值为2的是 D 。

A．(p++)->m B．*(p++)->m C．(*p).m D．*(++p)->m

data next …

b NULL a x c r p

q

11．若已建立上面的链表结构，指针p、q分别指向图中所示结点，则不能将q所指的结点插入到链

表末尾的一组语句是 C 。

A．q->next=NULL; p=p->next; p->next=q; B．p=p->next; q->next= p->next; p->next=q; C．p=p->next; q->next= p; p->next=q;

32

D．p=(*p).next; (*q).next=(*p).next; (*p).next=q;

12. 若已建立上面的链表结构，指针p、q分别指向图中所示结点，则不能将q所指的结点c插入到

a和b之间并形成新的链表的语句组是 B 。

A．(*q).next=(*p).next; (*p).next=q; B．p->next=q; q->next=p->next; C．q->next=p->next; p->next=q; D．(*p).next=q; (*q).next=&b;

13. 若已建立上面的链表结构，指针p、q分别指向图中所示结点，则能将p所指结点从链表中删除

并释放该结点的语句组是 C 。

A．free(p);r->next=p->next; B．p=p->next; r->next=p; free(p);

C．(*r).next=(*p).next; free(p); D．p=p->next; r->next=p;r=r->next;free(r); 14.A 15.C 16.C 17.B 18.D 19.B 20.C C

21．下面对typedef的叙述中不正确的是 B 。

A．用typedef可以定义各种类型名，但不能用来定义变量 B．用typedef可以增加新类型

C．用typedef只是将已存在的类型用一个新的标识符来代表 D．使用typedef有利用程序的通用移值

22．已知 enum week{sun,mon,tue,wed,thu,fri,sat}day；则正确的赋值语句是 D 。

A．sun=0； B．san=day； C．sun=mon； D．day=sun； 23. enum color{red,green,yellow=5,white,black}定义了一枚举类型。编译程序为值表中各标识

符分配的枚举值依次为 C 。

A．1、2、3、4、5 B．0、1、5、2、3 C．0、1、5、6、7 D．3、4、5、6、7

二、填空题（共44分，每题4分）

1．以下程序的运行结果是 20,y 。

# include \struct data { int x; char c; };

33

void func(struct data *b) { b->x=20;

b->c='y'; }

void main()

{ struct data a={10,'x'}; func(&a);

printf(\}

2．以下程序的运行结果是 61,60,10 80,41 。

# include \struct st { int x；

int *y； } *p；

void main()

{ int dt[4]={ 10,20,30,40 };

struct st aa[4]={50,&dt[0],60,&dt[1],70,&dt[2],80,&dt[3]},*p=aa; printf(\ p+=2;

printf(\}

3．以下程序的运行结果是 zhao liu li si zhang san

wang wu 。

# include \ struct man

{ char name[20]; int age;

}person[]={{\void main() { int i,j,k;

struct man tmp; for(i=0;i<3;i++)

{ for(k=i,j=i+1;j<4;j++)

34

}

if(person[j].age>=person[k].age) k=j;

tmp=person[k]; person[k]=person[i]; person[i]=tmp; }

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

puts(person[i].name);

4．以下程序的运行结果是 Zhao 。

# include \struct stu { int num;

char name[10]; int age; };

void fun(struct stu *p)

{ printf(\void main()

{ struct stu st[3]={{9801,\

fun(st+2); }

5. 以下程序能输入两个复数，并将其和以复数形式输出。

# include \struct complex { float re;

float ie;

}; /* 求两个复数之和的函数 */ struct complex *add(struct complex x, struct complex ＊y) { struct complex *z;

z=(struct complex *)malloc(sizeof(struct complex)); z->re=x.re+y->re; z->ie=x.ie+y->ie; return(z);

} /* add 函数定义结束 */ void main()

{ struct complex a,d,*b=&d,*c;

scanf(\

scanf(\ &b->re,&b->ie ); c=add(a,b);

printf(\c->re,ｃ->ie );

35

}

6．下面程序的功能是输入学生的姓名和成绩，然后输出。

# include \struct stuinf

{ char name[20]； /* 学生姓名 */

int score； /* 学生成绩 */ }stu, *p=&stu； void main()

{ printf(\；

gets( p->name )； printf(\；

scanf(\， &p->score )；

printf(\， p->name ， p->score )； }

7．结构体数组中存有三人的姓名和年龄，以下程序输出三人中最年长者的姓名和年龄。

# include \struct man

{ char name[20]; int age;

}person[]={\void main()

{ struct man *p,*q; int old=0

for(p=person;p age)

{q=p; old=p->age ;}

printf(\q->name,q->age ); }

8．下面的程序按学生的姓名查询其成绩排名和平均成绩。查询可连续进行，直到输入0才结束。

# include \# include \#define NUM 4 ? struct student ? { int rank；

char name[10]； int score； ???}stu[ ]={ 3，\，89，4，\，78，1，\，95，2，\，90}； void main()

36

????????{ char str[10]； ???????? int i； ???????? do

{ printf(\；

???????? scanf(\，str)； ???????? for( i=0；i

???????? if( strcmp(stu[i].name,str)==0 )

???????? { printf(\，stu[i].name)； ???????? printf(\，stu[i].rank)； ???????? printf(\，stu[i].score)； ???????? break ； ???????? }

???????? if( i==NUM ) printf(\； ???????? }while( strcmp(str，\； ???????}

?9. 以下程序段统计链表中结点的个数，其中first为指向第一个结点的指针（链表不带头结点）。

struct link { char data ;

struct link *next; };

....

struct link *p,*first; int c=0; p=first;

while( p!=NULL ) { c++ ; p= p->next ; }

10. 以下程序的功能是：读入一行字符(如：a、...y、z)，按输入时的逆序建立一个链接式的结点序列，即先输入的位于链表尾（如下图），然后再按输入的相反顺序输出，并释放全部结点。

# include \

void main()

{ struct node

{ char info；

struct node *link； } *top，*p；

37

char c； top=NULL；

while((c= getchar( )) !='\\n' )

{ p=(struct node *)malloc(sizeof(struct node))；

p->info=c；

p->link= top ； top=p； }

while( top )

{ p=top ；

top=top->link； putchar(p->info)； free(p)； }

}

11．下面函数的功能是创建一个带有头结点的链表，将头结点返回给主调函数。链表用于储存学生

的学号和成绩。新产生的结点总是位于链表的尾部。

#define LEN sizeof(struct student) struct student { long num；

int score；

struct student *next； }；

struct student *creat()

{ struct student *head=NULL,*tail；

long num； int a；

tail= (struct student *) malloc(LEN)； do

{ scanf(\；

if(num!=0)

{ if(head==NULL)

head=tail；

else tail=tail->next ； tail->num=num； tail->score=a；

tail->next=(struct student *)malloc(LEN)； } else

tail->next=NULL；

38

}while(num!=0)；

return( head )； }

三、编程题（共32分，每题8分）

1．编写程序，输入一时间，实现在屏幕上显示一秒后的时间。输入、显示格式为HH:MM:SS。

程序需要处理以下三种特殊情况：

⑴ 若秒数加1后为60，则秒数恢复到0，分钟数增加1； ⑵ 若分钟数加1后为60，则分钟数恢复到0，小时数增加1； ⑶ 若小时数加1后为24，则小时数恢复到0。

2．有若干个学生的记录(包括学号,姓名, 出生年份，年龄)，请编写函数，该函数的功能是：根据

输入的当年年份，计算每个学生的年龄（当年-出生年份），存入学生信息中，并输出年龄大于20的所有学生的信息。当年年份在主函数中输入，学生信息可以在主函数中初始化（年龄无值）。 3．学生的记录由学号和成绩组成，N名学生的数据已在主函数中放入结构体数组s中，请编写函数

fun，它的功能是：把指定分数范围内的学生数据放在b所指的数组中，分数范围内的学生人数由函数值返回，在主函数输出结果。

例如，输入的分数是60和69， 则应当把分数在60到69的学生数据进行输出，包含60分和69分的学生数据。主函数中将把60放在low中，把69放在heigh中。

4．有两个链表a和b，设结点中包含学号、姓名。从a链表中删去与b链表中有相同学号的结点。

1.

#include struct time{ };

void main() {

int hour,minute,second;

struct time t;

do{ printf(\请输入时间:\);

scanf(\,&t.hour,&t.minute,&t.second);

if(t.hour<0||t.hour>23||t.minute<0||t.minute>59||t.second<0||t.second>59)

printf(\时间格式错误,请重输入!\\n\); break; else

}while(1); if(t.second==60){ }

39

t.second++;

t.minute++; t.second=0;

if(t.minute==60){ } 2.

#include struct student {int num; char name[20];

int birthyear;

int age; }; void main() {

void CalcAge(struct student stu[],int n,int year); void print(struct student stu[],int n,int age);

struct student stu[]={{1,\,1988,0},{2,\,1991,0},{3,\,1989,0}}; printf(\请输入今年:\); scanf(\,&year); CalcAge(stu,3,year);

printf(\年龄大于20的学生有:\); } }

printf(\下一秒是:%d:%d:%d\\n\,t.hour,t.minute,t.second);

t.hour=0; t.hour++; t.minute=0;

if(t.hour==24){

int year;

print(stu,3,20); }

void CalcAge(struct student stu[],int n,int year) { }

void print(struct student stu[],int n,int age) {

int i;

for(i=0;i

stu[i].age=year-stu[i].birthyear;

int i;

for(i=0;i

40

}

if(stu[i].age>age)

printf(\,stu[i].num,stu[i].name,stu[i].birthyear,stu[i].age);

41

3.

#include struct student {int num; char name[20];

float score; }; void main() {

int select(struct student s[],int n, float low,float high,struct student b[]); void print(struct student b[],int n);

struct student s[]={{1,\,70},{2,\,80},{3,\,90}}; int count; float low,high;

printf(\请输入分数段:\\n\); scanf(\,&low,&high);

printf(\指定分段的学生有%d个\\n\,count);

struct student b[3];

count=select(s,3,low,high,b); print(b,count); }

int select(struct student s[],int n, float low,float high,struct student b[]) { }

void print(struct student b[],int n) { }

int i;

for(i=0;i

printf(\,b[i].num,b[i].name,b[i].score); int i,count=0; for(i=0;i

if(s[i].score>=low&&s[i].score<=high) { }

b[count]=s[i]; count++;

return count;

42

4.

#include #include #define N 10

typedef struct student {

int num; float score;

struct student *next; }STU;

STU *create() {

int i;

STU *p,*head=NULL,*tail=head; for (i=0;i

p=(STU *)malloc(sizeof(STU)); scanf(\,&p->num,&p->score); p->next=NULL; if (p->num<0) {

free(p); break; }

if(head==NULL) head=p; else

tail->next=p; tail=p; }

return head; }

void output(STU *p) {

while (p!=NULL) {

printf(\,p->num,p->score); p=p->next; } }

43

STU *del(STU *a,STU *b) {

STU *head,*p1,*p2;

head=a; //让head结点指向链表a的头部 while (b!=NULL) {

p1=p2=head; //每次循环前让p2始终指向删除后链表的头部 while (p1!=NULL) {

if (b->num==p1->num) //学号相同，删除结点信息

if(p1==head) //如果删除的是头结点，则头结点位置要后移 {

head=p1->next; free(p1); p1=p2=head; }

else //如果删除的是中间结点 {

p2->next=p1->next; free(p1); p1=p2->next; }

else //学号不同，则p1,p2指针依次后移 {

p2=p1; p1=p1->next; } }

b=b->next; }

return head; }

int main() {

STU *a,*b,*c;

printf(\请输入链表a的信息，学号小于零时结束输入：格式(学号 成绩)\\n\); a=create();

printf(\请输入链表b的信息，学号小于零时结束输入：格式(学号 成绩)\\n\); b=create();

44

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