上海交大C++程序设计试题集(含答案)

程序设计试题集

一、 单项选择题

1.1．定义一个具有10个元素的整型数组，应当使用代码是

A．int a[10]; B．int a[2, 5]; C．int a[]; D．int *a[10];

1.2．设int a = 8, b = 7, c = 6, x = 1；执行以下语句后x的值是 if (a > 6) if (b > 7) if (c > 8) x = 2; else x = 3;

A．0 B．1 C．2 D．3

1.3．下列代码中，正确的数组定义是

① int a[ ] = {―string‖}; ② int a[5] = {0, 1, 2, 3, 4, 5}; ③ char a = {―string‖}; ④ char a[ ] = {0, 1, 2, 3, 4, 5}; A．① B．② C．③ D．④

1.4．字符串‖abc\\x43\\\\\\np\\102q‖的长度是 A．9 B．12 C．13 D．17

1.5．执行下列程序后,输出的结果是

#define M(a, b) (a) > (b)?(a)+(b):(a)-(b) void main()

{ int i = 10, j = 15; printf(―%d\\n‖, 10*M(i, j)); } A．10 B．25 C．250 D．-50

1.6．执行下列程序后,输出的结果是

#define M(a, b) (a) > (b)?(a):(b)

void main()

{ int i = 10, j = 5; printf(―%d\\n‖, M(i, j)*10); } A．10 B．5 C．100 D．150

1.7．计算立方数时，不可能引起二义性的宏定义是

A. #define S(x) x*x*x B．#define S(x) (x)*(x)*(x) C．#define S(x) (x*x*x) D．#define S(x) ((x)*(x) *(x))

1.8．下列代码中，正确的是

A. char a[3][ ] = {?abc‘, ?1‘}; B. char a[ ][3] = {?abc‘, ?1‘}; C. char a[3][ ] = {―ab‖, ―12‖}; D. char a[ ][3] = {―ab‖, ―12‖};

1.9．设char str1[10] = ―ABCDE‖, str2[10] = ―xyzuvw‖; 则执行以下语句后的输出结果是

printf(―%d‖, strlen(strcpy(str1, str2))); A．12 B．11 C．8 D．6

1.10．以只写方式打开一个二进制文件，应选择的使用方式是

1--34 注：解答写在答卷纸上，试卷中的解答不评分

A．‖a+‖ B．‖w+‖ C．‖rb‖ D．‖wb‖

1.11．设int x = 8, y, z; 执行y = z = x--; x = y == z后，变量x的值是 A．0 B．1 C．8 D．9

1.12．设变量m ，n ，a ，b ，c ，d均为0，执行(m = a==b)||(n=c==d)后，m ，n的值是 A. 0 ，0 B. 0 ，1 C. 1 ，0 D. 1 ，1

1.13．设int x[ ] = {2, 6, 5, 7, 9, 15, 12}, *p = x; 则不能正确引用数组元素的表达式是

A．*（p--） B．*(--p) C．*(p++) D．*(++p)

1.14．根据变量定义“static int b[5]；”，b[4]的值是。 A．1 B．0 C．2 D．不确定

1.15.设int a = 9, b = 8, c = 7, x = 5；执行语句 if (a > 7) if (b > 8) if (c > 9) x = 3; else x = 4; 后x的值是

A．1 B．5 C．3 D．4

1.16 下列字符列中，可以作为“字符串常量”的是 A. ABC B. \ABC\′abc′ D. ′a′

1.17下列数据类型中，不属于构造类型是

A. 实型 B．数组型 C．结构型 D．联合（共用）型

1.18下面所列常量中，都是C语言整型常量的是。

A. 0xffff 和 611 B．01b 和 0xa1 C．986.012 和 0667 D．2e4 和 0x

1.19若有以下变量定义和输入语句，要求a1、a2、c1和c2的值分别为10、20、A和B。是正确的输入方式。

int a1, a2; char c1, c2;

scanf(″%d%c%d%c″, &a1, &c1, &a2, &c2)

A. 10 A 20 B↙ B．10 A 20B↙ C．10A 20 B↙ D．10A 20B↙

1.20 若变量b的值为3，则执行语句 b += b -= b*b后，变量b的值是（ ）。 A. 3 B．0 C．-12 D．9

1.21 若a、b和c均为整型变量，则执行以下语句后，变量a、b和c的值为（ ）。 a = 0; b = 2; c = 1; a++ && ++b || ++c

A．1、3、2 B．0、3、2 C．1、2、2 D．0、2、2

1.22 将数学公式√|yx + ey| 写成C表达式，正确的是。 A．sqrt(abs(pow(x, y) + exp(y))) B．sqrt(abs(pow(y, x) + exp(y)))

2--34 注：解答写在答卷纸上，试卷中的解答不评分

C．sqrt(fabs(pow(x, y) + exp(y))) D．sqrt(fabs(pow(y, x) + exp(y)))

1.23 函数调用时，下列说法中不正确的是

A. 形参不分配内存 B．实参和形参可以同名 C．主调函数和被调用函数可以不在同一个文件中 D．函数可以使用全局变量

1.24 若有变量定义：“int i, j = 7, *p = &i;”，则与“i = j;”等价的代码是 A. i = *p; B． *p = *&j; C． i = &j; D． i = **p;

1.25 若希望存储字符串，下列各代码中，正确的是

A. char s[5] = {\′A′, ′B′, ′C′, ′D′, ′E′}; C. char *s; s = \

1.26 设有代码“int a = 3;”，则执行了语句“a += a -= a * a ；”后，变量a的值是 A. 3 B. 0 C. 9 D. –12

1.27 设有如下定义，则正确的叙述为

char x[ ] = \， y[ ] = {'a', 'b', 'c', 'd', 'e', 'f', 'g'}; A．x和y的长度和内容相同 B．x和y的长度相同

C．x的长度大于y的长度 D．x的长度小于y的长度

1.28 设a,b为字符型变量，执行scanf(\a=%c,b=%c\, &a, &b)后使a为',A',,b为',B',，从键盘上的正确输入是

A. 'A''B' B．'A', 'B' C．A=A,B=B D． a=A,b=B

1.29若有以下的定义，则值为3的表达式是

int a[ ] = {1,2,3,4,5,6,7,8,9,10}, *p = a; A．p+=2，*(p++) B．p+=2, *++p C．p+=3, *p++ D．p+=2, ++*p

1.30设a为5，执行下列代码后，b的值不为2的是

A. b = a/2 B. b = 6-(--a) C. b = a%2 D. b = a < 3 ? 3: 2

二、填空题

2.1．设 int x[ ] = {1, 2, 3, 4}, y, *p = &x[1];则执行语句: y = (*--p)++; 后变量y的值为▁▁▁▁ 。

2.2.下面函数的功能是寻找链表h中最大值，并返回。试给出其中空框中的代码。

struct node { int val; struct node *next;}; int traveLink(struct node *h) { struct node *p; int m;

for(m = h->val, p = h; p != NULL; ▁▁▁▁) if(▁▁▁▁) m = p->val； return m; }

3--34 注：解答写在答卷纸上，试卷中的解答不评分

2.3.下面函数的功能是寻找链表h中最小值，并返回。试给出空框中的代码。

struct node { int val;

struct node *next; };

int traveLink(struct node *h) { struct node *p; int m;

for(m = h->val, p = h; p != NULL; ▁▁▁▁) if(▁▁▁▁) m = p->val； return m; }

2.4．希望通过函数调用，能改变某个int类型的变量值，则对应形参的类型是▁▁▁▁。

2.5．设 FILE *fp; 函数调用fp = fopen(―ABC.dat‖, ―r‖)的作用是▁▁▁▁。

2.6．设 int a[4][5], *p = a[3]; 该指针变量p指向的元素是▁▁▁▁。

2.7设int x = 4; 以下表达式的值是▁▁▁▁ 。 x += x *= x + 1

2.8．执行语句“for(j = k = 0; j – 10; k += j++);”后k的值是▁▁▁▁ 。

2.9．若d是已定义的双精度变量，再定义一个指向d的指针变量p的代码是▁▁▁▁。

2.10．以下分别是算术、关系和逻辑运算符： +， &&， <, ! 其优先级最低的是_________ 。

2.11．希望通过函数调用，能改变某个int类型的变量值，则在这样的函数体中，应该采用▁▁▁▁方式引用与该变量对应的形参，才能改变这个变量的值。

2.12．设有FILE *fp; 函数调用fclose(fp)的作用是_________。

2.13．设 int a[2][5], *p = a[1]; 该指针变量p指向的元素是▁▁▁▁。

2.14．设 float *pm, m = 2.718;根据下列图示，建立指针变量pm和变量m之间的关系的赋值语句是_________。

m pm 2.718

2.15.下面函数的功能是将链表h中的末表元移止首表元之前，并返回。试给出其中空框中的代码。

struct node {

int val; struct node *next;

4--34 注：解答写在答卷纸上，试卷中的解答不评分

};

struct node * lastToFirstLink(struct node *h) { struct node *p;

if(h == NULL || h->next->next == NULL) return h; for(p = h; _________; p = p->next);

p->next->next = h; _________; p->next = NULL; return h; }

2.16．写出描述“a和b中有且只有一个小于x”的C表达式▁▁▁▁。

2.17．执行语句“for(j = k = 0; j – 8; k += j++);”后k的值是▁▁▁▁ 。

2.18．写出描述“x和y中有且只有一个大于z”的C表达式▁▁▁▁。

2.19．设a=1 ，b=2 ，c=3 ，d=4 ，则表达式a < b ? a : c < d ? a : d的结果为______。

2.20．设a为整型变量，表达数学关系式：10 < a < 15的C表达式是______。

2.21．若有定义：char a ; int b ; float c ; double d ; 则表达式a * b + d / c的值的类型为______。

2.22．设x 、y 、z 、t 均为int型变量，则执行以下语句后，t的值为______ 。 x = y = z = 1 ; t = ++x || ++y && ++z;

2.23．假定所有变量均已正确定义，下列程序段运行后 x 的值是______。 a = b = c = 0 ; x = 35 ;

if(!a)x-- ; else if(b); if(c)x = 3; else x = 4;

2.24．设有宏定义：#define F(N) 2*N

执行代码：printf(\后输出的结果是______。

2.25．表述20 < x < 30 或 x < - 100的C表达式是______。

2.26．设有代码“static int a[3][4]={{6 , 5} , {4 , 3} , {2 , 1}} ;”则a[1][1] 的值为______。

2.27． C代码“float (*f)[5];”的含义是______。

2.28．C程序有且只有一个________。

三、读函数或程序，写出函数的功能或程序的输出结果

3.1．#include int sigmaDigit (int n)

{ int s = 0;

while(n) {

5--34 注：解答写在答卷纸上，试卷中的解答不评分

s += n % 10; n /= 10; }

return s; }

void main()

{ printf(―sigmaDigit(12345) = %d\\n‖, sigmaDigit(12345)); }

3.2．

#include struct stu

{ int num; char name[15]; int age; }; void py(struct stu *p)

{ printf(―%s\\n‖, p->name); }

void main()

{ struct stu student[3] = {{1001, ―Sun‖, 25}, {1002, ―Ling‖, 23}, {1003, ―Shen‖, 22}}; py(student+2); }

3.3．

#include void main()

{ char str[ ] = ―ABCDEFG‖; int i;

for(i = 0; i < 7; i += 2) printf(―%s ‖, str + i); }

3.4．

#include void main()

{ int i, a[5];

for(i = 0; i < 5; i++) a[i] = 9 * (i + (i > 2 ? 4 : 0)) % 5; for(i = 4; i >= 0; i--) printf(―=‖, a[i]); }

3.5.

#include

void main()

{ char *a[6] = {―AB‖, ―CD‖, ―EF‖, ―GH‖, ―U‖, ―KL‖}; int i; for(i = 0; i < 4; i++) printf(―%s ‖, a[i]); }

6--34 注：解答写在答卷纸上，试卷中的解答不评分

3.5(2)

#include

char str[] = ―ABCDEFGHU KL‖; void main()

{ char *a[6] = {str, str+2, str+4, str+6, str+8, str+10}; int i; for(i = 0; i < 4; i++) printf(―%s ‖, a[i]); } 3.6

void fun(int a[], int n) {

int i = 0, j = n – 1, temp; while(i < j) { while(a[i] < 0) while(a[j] >= 0)

i ++;

j --;

if(i < j) {

temp = a[i]; a[i] = a[j]; a[j] = temp; } } } 3.7

#include #include

char *subStr(char *s1, char *s2, int pos, int len) { int i = 0; char *p = s2;

if(pos <= strlen(s1))

for(s1 += pos; *s1 && i < len; i++) *s2++ = *s1++; *s2 = '\\0'; return p; }

void main()

{

char *s1 = \ subStr(s1, s2, 2, 3); printf(\} 3.8

#include

int array(int *a, int n) { int x;

if(n == 1) return *a; x = array(a+1, n-1); return *a > x ? *a : x;

7--34 注：解答写在答卷纸上，试卷中的解答不评分

}

void main() { int a[] = {57, 73, 23, 67, 131, 79};

printf(\}

3.9

#include void postMsg(int msg); void main() {

int msg;

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

postMsg(msg);

}

void postMsg(int msg) { static int x = 0, y = 0; }

}

switch(msg) { case 0: x ++;

case 1: y ++; break; case 3: x ++;

default: printf(\

3.10

struct intNode * reverse (struct intNode *h) { struct intNode *p, *v1, *v2; v2 = h; v1 = NULL; while (v2 != NULL) {

p = v2->next; v2->next = v1; v1 = v2; v2 = p; }

return v1; }

3.11

void rp(int *s, int k) {

int t;

if (k <= 0) return;

rp(s+1, k-2);

t = *(s+k-1); *(s+k-1) = *s; *s = t; }

3.12

void seleS(int a[], int n) { int i, j, t, k;

8--34 注：解答写在答卷纸上，试卷中的解答不评分

for(i = 0 ; i < n-1; i++) {

for(k = i , j = i+1; j < n; j++) if(a[k] > a[j]) k = j; if(k != i) {

t = a[i]; a[i] = a[k];a[k] = t; } } } 3.13

void pp(char *s, int k) { char c;

if (k <= 0) return;

pp(s+1, k-2); c = s[k-1]; s[k-1] = s[0]; s[0] = c; }

3.14

struct intNode { int val; struct intNode * next;}; void freeLink(struct intNode *h)

{ intNode *p;

while(h != NULL) { p = h; h = h->next; free(p); } }

3.15

void s(int a[], int n)

{ int i, j, t;

for(i = 1 ; i < n; i++) { t = a[i]; for(j = i-1; j >= 0 && a[j] > t; j--) a[j+1] = a[j]; a[j+1] = t; } }

3.16

#include int fs(char *s) {

}

if(*s) return 1+fs(s+1); return 0;

void main()

{ char s[]=\

9--34 注：解答写在答卷纸上，试卷中的解答不评分

}

printf(\

3.17

#include #include

void ostr(char *s1, char *s2) { int i,j,k, len = strlen(s1);

for(k = 0; s2[k]; k++) { for(j = 0 ; s1[j] && s2[k] > s1[j]; j++); }

void main()

{ char a[20]= \ ostr(a, b); printf(\

}

3.18

#include

int f(int a) { int b = 0; static int c = 3; b++; c++; return (a+b+c); }

void main() { int i; }

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

for(i = len; i >= j; i--) s1[i+1] = s1[i]; s1[j] = s2[k];len++;

}

3.19

#include void s(int b[ ], int k) { int i, j, t;

for(i = 1; i < k; i++) {

for(t = b[i], j = i-1; j >= 0 && t < b[j]; j--) b[j+1] = b[j]; b[j+1] = t; } }

void main()

{ int i, a[5] = {6, 12, 7, 11, 5}; s(a, 5);

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

10--34 注：解答写在答卷纸上，试卷中的解答不评分

printf(\ }

3.20

#include void s(int a[ ], int k) { int i, j, t;

for(i = 0; i < k-1; i++)

for(j = 0; j < k-i-1; j++) if (a[j] > a[j+1])

{ t = a[j]; a[j] = a[j+1]; a[j+1] = t;} }

void main()

{ int i, b[5] = {9, 6, 7, 5, 8};

s(b, 5);

for(i = 0; i < 5; i++) printf(〞=〞, b[i]); printf(〞\\n〞); }

3.21

#include int mDigit(int n) { int c = 9;

while(n > 0) { if((d = n % 10) < c) c = d; n /= 10; } return c;

} void main()

{ printf(\M\\n\, mDigit(9657)); }

3.22

#include void s(int b[ ], int k) { int i, j, t, m;

for(i = n-1; i > 0; i--) {

for(m = i, j = i-1; j >= 0; j--) if(b[j] > b[m]) m = j; if(m != i)

{ t = b[i]; b[i] = b[m]; b[m] = t;} } }

void main()

{ int i, a[5] = {6, 12, 7, 11, 5}; s(a, 5);

11--34 注：解答写在答卷纸上，试卷中的解答不评分

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

3.23

#include void main()

{ int i, j, sum;

for(sum = 0, i = 1; i <= 4; i++) { for(j = 1; j <= i; j++) sum += i * j; printf(″=″, sum) } }

3.24

#include

int a, b;

void p(int c, int *d)

{ c = a + b; *d = a – b; printf(″=, =″, c, *d); }

void main()

{ a = 1; b = 2; p(a, &b); printf(″=, =\\n″, a, b); }

3.25．当输入为12 78 ↙时。 #include int i, j, k;

void main()

{ scanf(″%d%d″, &i, &j);

do { k = i % j; i = j; j = k; } while (j != 0); printf(″%d\\n″, i); }

3.26

int reverseNum(int n) {

return reverseDigit(n, 0); }

reverseDigit(int low, int high) {

if(low == 0) return high;

return reverseDigit(low/10, high*10+low);

12--34 注：解答写在答卷纸上，试卷中的解答不评分

}

四、完全程序或函数

4.1．将一字符串中的大写英文字母改成小写。 void upToLow(char *str) {

while ( ▁▁(1)▁▁ )

{ if( ▁▁(2)▁▁ ) *str -= ?A‘ – ?a‘; str++; } }

4.2．以下函数用来在w数组中插入x。形参n是w数组中的整数个数。数组w中的整数已按从小到大的顺序排列，插入后数组w中的整数仍有序。 void fun(int w[], int x, int n) { int i, p;

p = 0; w[n] = x;

while(x > w[p]) p++;

for(i = n; ▁▁(1)▁▁; i--) w[i] = ▁▁(2)▁▁ ; ▁▁(3)▁▁ = x; }

4.3．下面函数pi()的功能是根据以下公式求π值（直到最后一项小于10-6为止）。 π 1 1 2 1 2 3 1 2 3 4

—－ = 1 + — + — * — + — * — * — + — * — * — * — +?? 2 3 3 5 3 5 7 3 5 7 9 double pi( )

{ double s = 0.0, t = 1.0; int n; for( n = 1; t >= 0.000001; n++) { s += t; t = t * ▁▁(1)▁▁; }

return 2.0 * s; }

4.4．使用结构型计算复数x和y的和。

struct comp { float re, im; };

struct comp addComp(struct comp x, struct comp y) { struct comp z;

z.re = ▁▁(1)▁▁ ; z.im = ▁▁(2)▁▁ ; return z; }

13--34 注：解答写在答卷纸上，试卷中的解答不评分

4.5.下面函数是求计算整数x的逆数。例如，x为1234，则函数的计算结果是4321。 int reverseNum(int x) { int s = 0;

while(x != 0) {

s = ▁▁(1)▁▁; x = ▁▁(2)▁▁; }

return s; }

4.6．将一字符串中的小写英文字母改成大写。 void lowToUp(char *str) { int i = 0;

while (▁▁(1)▁▁)

{ if(▁▁(2)▁▁) str[i] -= ?a‘ – ?A‘; i++; }

}

4.7．以下程序求出所有各位数字的立方和等于1099的3位数。 #include void main()

{ int a, b, c; /* 变量定义 */ for(a = 1; a <= 9; a++) for(b = 0; b <= 9; b++) for(c = 0; c <= 9; c++)

if ( _____（1）____ == 1099) printf(“%d\\n”, ____（2）____ ); }

4.7(2)．以下程序求出所有各位数字的立方和等于1099的3位数。 #include

void main()

{ int k, a, b, c; /* 变量定义 */ for(k = 100; k <= 1000; k++) { a = ______ ; b = _______ ; c = ________ ;

if ( _____（1）____ == 1099) printf(“%d\\n”, k ); } }

4.8．以下函数输出整数的每位数字，并在数字之间输出一个逗号字符。例如，对于整数2345，函数输出为：2，3，4，5。 void writeDigits(int n)

14--34 注：解答写在答卷纸上，试卷中的解答不评分

{ int a[20], i;

i = 0; /* 对n进行分拆，各位数字自低位到高位存于数组a */ do { a[i++] = ____(1)____ ; ____(2)____; } while (n);

for(i--; i > 0; i--)

printf(\自高位到低位输出 */ printf(\ }

4.9．函数Node *merge(Node *h1, Node *h2)实现由链表h1和h2产生一个新链表，其中h1和h2分别是两个从小到大有序链表首表元指针，新链表包含或在链表h1，或在链表h2中出现的元素。要求新链表也从小到大链接，并且没有重复的表元。设链表表元类型ELE的定义为：

typedef struct ele { int val;

struct ele *next;

}Node;

Node *merge(Node *h1, Node *h2) {

Node *h = NULL, *tail = NULL, *p, *q; while(h1 || h2) {

if(h2 == NULL || ( ____(1)____ )) { p = h1; h1 = h1->next; }

else{

p = h2; h2 = h2->next; }

if(tail == NULL || ____(2)____) {//只复制与末表元不相等的表元 q = (Node *)malloc(sizeof(Node)); q->val = p->val; if( ____(3)____ ) h = tail = q; else tail = ____(4)____; }

}

if(tail) ____(5)____; return h; }

4.10．函数f(NODE1 *h)参照无序整数链表，生成一个从小到大顺序链接的有序整数链表，新链表中没有重复的整数，新链表的表元有整数和该整数在原链表中出现的次数等信息。 typedef struct node1 { /* 原无序整数链表的表元类型 */ int val; struct node1 *next;

}NODE1;

typedef struct node2 { /* 从小到大顺序链接的整数链表的表元类型 */ int val; int count; struct node2 *next;

15--34 注：解答写在答卷纸上，试卷中的解答不评分

}NODE2;

NODE2 *f(NODE1 *h)

{ NODE2 *u, *v, *p, *list;

for(list = NULL; h ; h = h->next) { /* 顺序考察已知链表 */

for(u = NULL, v = list; ___(1)___ ; u = v, v = v->next);/* 寻找插入位置 */ if ( ___(2)___ ) v->count++;

else { p = (NODE2 *)malloc(sizeof(NODE2));

p->val = h->val; ___(3)___ ;

if(___(4)___) list = p; else u->next = p; ___(5)___ ; } } return list; }

4.11．某服务公司征询顾客意见，以考核公司的 n(<40) 位服务员的工作业绩。设服务员已按 1、2、3、?顺序连续编号，顾客意见是顺序列出第一名(最佳)至第十名的服务员编号。设所收到的信息已存于正文文件SOURCE.DAT中，每位顾客给出的10服务员编号用一个正文行表示，服务员编号之间用空白符分隔，某些名次位置上的服务员编号可以为 0，表示该顾客认为相应名次空缺，没有合适的服务员，编号0称为空缺编号。

若一行意见信息中有不是服务员编号的整数，也不是空缺编号，或所给的服务员编号有重复出现，或一行有十个以上编号，或不足十个编号(包括空缺编号)，则这条意见信息作废。 程序综合顾客对各服务员的评定情况，给每位服务员累计计分，各名次得分标准如下： 一 二 三 四 五 六 七 八 九 十 15 12 9 7 6 5 4 3 2 1

程序最后顺序输出各服务员各名次所得票数和他的合计得分。

程序中函数fgets(buf, 80, fp)实现从指定文件读入一行信息，若文件结束返回NULL，否则返回buf。

#include #define N 40

#define FNAME \

int mark[] = {15, 12, 9, 7, 6, 5, 4, 3, 2, 1};

int score[N][10]; /* score[i][j] 是 i 号服务员得j+1名的票数 */ char buf[81], *p;

FILE *fp;

int i, j, k, c, d, error, b[10];

void main()

{ for(i = 0; i < N; i++) for(j = 0; j < 10; j++) score[i][j] = 0; if((fp = fopen(FNAME, \

{ printf(\ }

while ((p = fgets(buf, 80, fp)) != NULL) {

error = 0; k = 0; /* error出错标志, k 编号个数*/

while (!error) {

16--34 注：解答写在答卷纸上，试卷中的解答不评分

while (*p == ' ' || *p == '\\t') p++; /* 跳过空白类字符 */ if (*p == '\\0' || *p == '\\n') { /* 一行结束 */

error = ___(1)___ ; break; /* 检查编号个数 */

}

if (*p < '0' || *p > '9') { /* 有非法字符 */

error = 1; break; /* 设定有错标志后，结束当前行 */

}

if (k == 10) { /* 已有了十个编号，不可再有 */

error = 1; break; /* 设定有错标志后，结束当前行 */ }

c = 0; /* 译出一个编号 */

while (*p >= '0' && *p <= '9') {

c = ___(2)___ ; p++;

}

if (c >= N) { error = 1; break; } /* 非法编号 */ b[k++] = c; /* 编号存入 */

if (c != 0) { /* 一个非空缺编号 */

for(i = 0; ___(3)___ ; i++); /* 检查服务员编号是否有重复*/ error = ___(4)___ ; /* 如有重复编号, 则置出错标志 */ }

}

if (!error)

for(i = 0; i < k; i++) if (b[i]) ___(5)___ ; }

fclose(fp);

for(i=1; i < N; i++) /* 输出结果 */

{ printf(\输出服务员编号 */

for(d = 0, j = 0; j < 10; j++) {

printf(\

d += score[i][j] * mark[j]; /* 求合计得分 */ }

printf(\输出合计得分 */ }

printf(\ }

4.12．以下函数的功能是已知链表首指针, 将链表颠倒，返回颠倒后的链表的首指针。设链表表元类型NODE的定义如下所示。 typedef struct node {

int val; struct node *next; } NODE;

NODE * reverse (NODE *h) { NODE *p, *v1, *v2;

v2 = h;/* v2 指向链表的首表元*/ v1 = NULL; /* 已颠倒部分为空*/

17--34 注：解答写在答卷纸上，试卷中的解答不评分

while (v2 != NULL) { /* 还未颠倒完，循环 */

p = v2->next; ____(6)____ ; v1 = v2; v2 = p; }

____(7)____ ;

}

4.13．已知数组的n个元素，生成一个从小到大的有序链表，函数返回链表首指针。 设链表表元类型NODE的定义如下所示。 typedef struct node {

int val; struct node *next; } NODE;

NODE *cSortList(int *a, int n)

{ NODE *u, *w, *p, *h = NULL; int k;

for(k = 0; k < n; k++) { p = (NODE *)malloc(sizeof(NODE)); p->val = a[k]; u = h;

while ( ____(8)____ ) { w = u; u = u->next; }

if ( ____(9)____ ) h = p; else _____(10)____ ; p->next = u; }

return h;

}

4.14本题给出的函数orderStd(stdType std[], int n)根据存于数组中的学生成绩信息，求各学生从高分到低分的名次。要求成绩相同的学生，他们的名次相同，所有名次连续编号，不考虑同一名次的人数多少。设数组的每个元素对应一个学生，是一个结构，有学生的学号、姓名、成绩和名次。函数先按成绩从高分到低分顺序排序，然后求得学生的名次。排序采用改进的冒泡法，即下一次比较范围的上界是上一轮扫视比较时最后一次交换的位置。另为了避免排序时交换结构，引入指针数组，变交换结构为交换指针。 typedef struct node {

char no[8]; /* 存储学号 */

char *name; /* 存储指向名字字符串的指针 */ int score; /* 存储成绩 */ int order; /* 存储名次 */ }stdType;

stdType **ptar, *t;

void orderStd(stdType std[ ], int n) { int m, i, j;

ptar = (stdType **)malloc( ___(1)___ );

for(i = 0; i < n; i++) /* 为数组 ptar 设定初值 */

18--34 注：解答写在答卷纸上，试卷中的解答不评分

ptar[i] = std+i;

/* 以下采用冒泡法排序, 按成绩由高到低排序 */ m = n-1;

while ( ___(2)___ ) {

for( j = 0, i = 0; i < m; i++) if ( ___(3)___ ) { t = ptar[i];

ptar[i] = ptar[i+1]; ptar[i+1] = t; j = i ; }

m = j; }

for(ptar[0]->order = i = 1; i < n; i++) /* 按排名次 */ ptar[i]->order = ptar[i]->score == ___(4)___ ? ___(5)___ ; free(ptar); }

4.15函数

intNode * searchDOLink(intNode *h, int key， intNode ** pp)

实现在已知有序(从小到大)链表h中查找值为key的新结点的插入位置(插入结点的前驱结点指针通过指针参数pp带回，插入结点的后继结点指针通过函数值返回)。

函数intNode *sortCopy(intNode *t)利用函数searchDOLink ()实现由已知链表t复制出一个有序链表返回。设链表表元类型intNode的定义如下: typedef struct node { int val;

struct node *next; } intNode;

intNode * searchDOLink(intNode *h, int key， intNode ** pp) { intNode *v = h, *u = NULL;

while ( (1) && (2) ) { u = v; v = v->next; }

*pp = u; return v; }

4.16函数intNode *sortCopy(intNode *t)利用函数searchDOLink ()实现由已知链表t复制出一个有序链表返回。设链表表元类型intNode的定义如下: typedef struct node { int val;

struct node *next; } intNode;

19--34 注：解答写在答卷纸上，试卷中的解答不评分

intNode *sortCopy(intNode *t)

{ intNode *h = NULL，/* 新链表的首指针 */

*q, /*新结点插入处的前驱结点指针 */ *p, /*新结点插入处的后驱结点指针 */ *W /*新结点指针 */ ;

for(; t != NULL; t = t->next) { /*逐一考察原链表的结点*/ p = searchDOLink( ___(1)___ );

w = (intNode *)malloc(sizeof(intNode)); w->val = t->val; w->next = p;

if(q == NULL) (2) = w; else (3) = w; }

return h; }

4.17以下程序找出所有各位数字的立方和等于1099的3位数。 设变量i是一个3位数，循环体将3位数变量i分拆出它的百位数字、十位数字和个位数字,然后判这三个数字的立方和是否是1099，若是就输出该变量的值。

#include void main()

{ int i , a , b , c ; /* 变量定义 */ for( i = 100 ; i <= 999 ; i++ ){

a = i/100; b = ___(1)___; c = i; if ( ___(2)___ == 1099) printf(\ } }

4.18函数struct intNode *searchLink(struct intNode *h, int key)在首指针为h的链

表中查找值为key的表元，返回该表元的指针。

设链表的表元类型为： struct intNode { int value; struct node *next;}; struct intNode *searchLink(struct intNode *h, int key) { while(___(3)___ && ___(4)___ != key) ___(5)___; return h; }

4.19以下程序将正文文件plain.txt中所有小写英文字母用其后继字母替换（如字母b用

字母c替换），字母z用字母a替换，其余字符保持不变，形成的密文显示在屏幕上。 #include #define N 1000 void main()

{ FILE *fp;

if((fp = fopen(___(6)___) == NULL) {

printf(”Can not open file\\n”) ; return ;

20--34 注：解答写在答卷纸上，试卷中的解答不评分

}

while((ch = fgetc(fp)) != EOF) { if( ___(7)___ ) ch++; else if ( ch == 'z' ) ch = a; printf(”%c”, ch); }

___(8)___; printf(”\\n”); }

4.20本程序从键盘输入n(0 < n < 100)个整数，计算并输出其中出现次数最多的元素。当

有多个不同元素有相同的最多出现次数时，选择值更大的元素。 [程序4.2]

#include void main()

{ int a[100], n, i, j, ind, c1, c2;

printf(〞输入n！\\n〞); scanf(〞%d〞, &n); for(i = 0; i < n; i++) scanf(〞%d〞, &a[i]); for(c2 = i = 0; i < n; i++)

{ for(c1 = 1, j = i+1; j < n; j++) if(a[j] == a[i]) ___(3)___ ;

if(c1 > c2 || c1 == c2 && ___(4)___ ) { ___(5)___ ; ind = i; } }

printf(〞其中 %d 出现 %d 次。\\n〞, a[ind], c2); }

4.21本程序是按以下格式输出杨辉三角形的前n(<20)行。

1 1

1

1 2 1

1 3 3 1

1 4 6 4 1 杨辉三角形有以下性质：

① 第一行只有一个元素1。

② 第i(≧2)行有i个元素，它的最左、最右元素为1，中间元素是它上一行(i-1)对应位

置元素与对应位置前一个元素之和。 #include int pas[20]; void main() { int n, i, j;

printf(〞输入n！\\n〞); scanf(〞%d〞, &n); pas[0] = ___(6)___ ;

printf(〞M\\n〞, pas[0]);

21--34 注：解答写在答卷纸上，试卷中的解答不评分

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

{ /* 由存储在pas中的第i-1行内容生成第i行内容，并重新存于pas */ pas[i-1] = 1;

for(j = ___(7)___ ; j > 0; j--) pas[j] = ___(8)___; for(j = 0; j < i; j++)

printf(〞M〞, pas[j]); printf(〞\\n〞); } }

4.22本程序求正文文件 st.dat 中不同的整数。程序中用数组b[]存储不同的整数，变量

k 为已存入b[]中的不同整数的个数，设不同整数个数小于1000。 #include #define N 1000 void main()

{ FILE *fp; b[N], d, i, k;

if((fp = fopen(___(6)___) == NULL) {

printf(”Can not open file\\n”); return; }

k = 0;

while( fscanf(fp, ”%d”, &d) == 1) { for(b[k] = d，i = 0; b[i] != d; i++); if(___(7)___) k++; }

___(8)___;

for(i = 0; i < k; i++) printf(”m”, b[i]); printf(”\\n”); }

4.23以下程序实现两个多项式相乘。多项式用链表表示，链表上的各表元按多项式的幂指

数降序链接。例如：

f(x) = 5.7x15 + 4.8x6 + 9.65 15 5.7 6 4.8 0 9.65 ∧

设两个多项式f(x)和g(x)分别为

f(x) = fnx + ?? + f1x + f0 g(x) = gmxm + ?? + g1x + g0 其积多项式为

s(x) = f(x)g(x) = skxk + ?? + s1x + s0 其中k = n+m，si = ∑fs*gt (0<= i <= k)

22--34 注：解答写在答卷纸上，试卷中的解答不评分

n

s+t = i

#include #include

typedef struct elem { int index; double coef; struct elem *next; }POLYNODE;

write(POLYNODE *g) { POLYNODE *p = g;

while (p) { printf(\” , p->coef);

if (p->index) printf(”*x^%d\

if (p->next && p->next->coef > 0) printf(”+”); p = p->next; }

printf(\ }

main()

{ POLYNODE *f, *g, *s, *inpoly(), *polymul();

f = inpoly(); g = inpoly(); s = polymul(f, g); write(s); }

POLYNODE *reverse(POLYNODE *g)

{ POLYNODE *u = NULL, *v = g, *w;

while(v) { w = v->next; v->next = u; u = v; v = w; } return u; }

POLYNODE *polymul(POLYNODE *f, POLYNODE *g)

{ POLYNODE *fp, *gp, *tail, *p = NULL, *q; int i, maxindex; double temp;

maxindex = f->index + g->index; g = reverse(g); for(i = maxindex; i >= 0; i--) { fp = f; gp = g;

while (fp != NULL && fp->index > i) fp = fp->next;

while (gp != NULL && gp->index < i - fp->index) gp = gp->next; temp = 0.0;

while(fp && gp)

if (fp->index + gp->index == i) {

temp += fp->coef * gp->coef; fp = fp->next; gp = gp->next; }

else if (fp->index + gp->index > i) fp = fp->next; else gp = gp->next; if (temp != 0.0) {

q = (POLYNODE *)malloc(sizeof(POLYNODE)); q->index = i; q->coef = temp; q->next = NULL;

23--34 注：解答写在答卷纸上，试卷中的解答不评分

if (p == NULL) p = q; else tail->next = q; tail = q; } }

g = reverse(g); return p; }

POLYNODE *inpoly()

{ POLYNODE *u, *v, *h = NULL, *p; int index; double coef; printf(\ while (index >= 0) {

printf(\ p = (POLYNODE *)malloc(sizeof(POLYNODE)); p->index = index; p->coef = coef; v = h;

while(v != NULL && index < v->index) { u = v; v = v->next; }

if (v == NULL || index > v->index) { p->next = v;

if (v == h) h = p; else u->next = p; } else v->coef += coef;

printf(\ }

return h; }

4.24函数merge(int a[], int n, int b[], int m, int *c)是将两个从小到大有序数组

a和b复制合并出一个有序整数序列c，其中形参n和m分别是数组a和b的元素个数。

void merge(int a[], int n, int b[], int m, int *c) { int i, j;

for(i = j = 0; i < n && j < m;)

*c++ = a[i] < b[j] ? a[i++] : b[j++]; while (___(1)___) *c++ = a[i++]; while (___(2)___) *c++ = b[j++]; }

4.25以下函数encode()和decode()分别实现对字符串的变换和复原。变换函数encode()

顺序考察已知字符串的字符，按以下规则生成新字符串：

(1) 若已知字符串的当前字符不是数字字符，则复制该字符于新字符串中。

(2) 若已知字符串的当前字符是一个数字字符，且它之后没有后继字符，则简单地将它自已复制到新字符串。

(3) 若已知字符串的当前字符是一个数字符，并且还有后继字符，假设这个数字符的面值为n,则将它的后继字符（包括后继字符是一个数字符）重复复制n+1次到新字符串。 (4) 以上述一次变换为一组，在不同组之间另插入一个下划线字符‘_‘用于分隔。

24--34 注：解答写在答卷纸上，试卷中的解答不评分

例如：encode()函数对字符串 26a3t2 的变换结果为 666_a_tttt_2

复原函数decode()做变换函数encode()相反的工作。即复制不连续相同的单个字符，而将一组连续相同的字符（不超过10个）变换成一个用于表示重复次数的数字字符和一个重复出现的字符，并在复原过程中掠过变换函数为不同组之间添加的一个下划线字符。

假定调用变换函数encode()时的已知字符串中不包含下划线字符。 int encode(char *instr, char *outstr) {

char *ip, *op, c; int k, n; ip = instr; op = outstr; while (*ip) {

if (*ip >= ?0? && *ip <= ?9? && *(ip+1) != ?\\0?) { n = ___(1)___ ; c = ___(2)___ ;

for(k = 0; k < n; k++) *op++ = c; } else ___(3)___ ; *op++ = ?_?; ip++; }

if (op > outstr) op--; ___(4)___ ;

return op - outstr; }

int decode(char *instr, char *outstr) { char *ip, *op, c; int n; ip = instr; op = outstr; while (*ip) {

c = *ip; n = 0;

while (*ip == c && n < 10) { ip++; n++; }

if(___(5)___)

*op++ = ?0? + n - 1; *op++ = c;

if(___(6)___) ip++; }

*op = ?\\0?; return op - outstr; }

4.26以下程序用古典的Eratosthenes的筛法求从2起到指定范围内的素数。如果要找出

2至10中的素数，开始时筛中有2到10的数，然后取走筛中的最小的数2，宣布它是素数，并把该素数的倍数都取走。这样，第一步以后，筛子中还留下奇数3、5、7、9；重复上述步骤，再取走最小数3，宣布它为素数，并取走3的倍数，于是留下5、7。反复重复上述步

25--34 注：解答写在答卷纸上，试卷中的解答不评分

骤，直至筛中为空时，工作结束，求得2至10中的全部素数。

程序中用数组sieve表示筛子，数组元素sieve[i]的值为1时，表示数i在筛子中，值为-1时表示数i已被取走。 #include #define MAX 22500 void main()

{ int i, leftin, range, factor, multiple; int sieve[MAX];

printf(\

scanf(\指出在多大的范围内寻找素数 */ for ( i = 2; i <= range; i++) /* 筛子初始化 */

(1) ;

leftin = range – 1; /* 筛中的个数置初值 */ factor = 1;

while(leftin > 0) {

factor = factor + 1;

if( sieve[factor] == 1) { /* 筛中最小数是素数 */ printf(“%d\\t“, factor); (2) ;

while (factor * multiple <= range) { if(sieve[factor * multiple] == 1) { (3) ; /* 移走素数的倍数 */ (4) ; /* 筛中的个数减一 */ }

(5) ; /* 倍数值增1 */ } }

} }

五、改错题

5.1函数sum(x, k)是求数组x的前k个整数的和。 /* 1 */ void sum(int x, int k) /* 2 */ { int i;

/* 3 */ for (i = 0; i <= k; i++) /* 4 */ s += *x; /* 5 */ return s; /* 6 */ }

5.2下函数writelink(head)是输出首指针为head的链表中各结点的数据。

struct node { int val;

struct node *next; };

/* 1 */ void plink(struct node head) /* 2 */ { for ( ; head != NULL; head++) /* 3 */ printf(“?”, head.val); /* 4*/ }

26--34 注：解答写在答卷纸上，试卷中的解答不评分

5.3. 函数sortTwo()的功能是使与函数的两个参数所对应的两个变量的值满足前一个不比后一个小的顺序。在函数发现它们不是要求的顺序时，函数就应该交换这两个变量的值，使它们变成满足要求的顺序。

/* 1 */ void sortTwo(int x, int y) /* 2 */ { int t;

/* 3 */ if (x > y) { t = x; x = y; y = t; } /* 4 */ }

5.4.函数inputx是输入k个整数到数组x中。 /* 1 */ void inputx(int x, int k) /* 2 */ { int i;

/* 3 */ for (i = 0; i

5.5.函数enters是将字符串s中的大写英文字母转换成小写英文字母，并返回字符串ｓ； /* 1 */ char *enters(char *s) /* 2 */ { char *t = s; /* 3 */ while (*t)

/* 4 */ { if (*t >= ‘A‘ | | *t <= ‘Z‘ ) /* 5 */ *t = *t – ?A‘ + ‘a‘; /* 6 */ t++; /* 7 */ }

/* 8 */ return *s; /* 9 */ }

5.7以下程序的目的是交换数据a、b。

/* 1*/ #include

/* 2*/ void swap(int *x, int *y) { /* 3*/ int tmp;

/* 4*/ tmp = x; x = y; y = tmp; /* 5*/ }

/* 6*/ void main() { /* 7*/ int a, b;

/* 8*/ scanf(\/* 9*/ swap(a, b);

/*10*/ printf(\/*11*/ }

5.8以下是一个将d盘根目录的data.txt文件内容输出到显示屏上的程序。输出时，将

其中的小写字母转换成大写字母输出。 /*1*/ #include /*2*/ void main() {

/*3*/ FILE *fp; char ch;

27--34 注：解答写在答卷纸上，试卷中的解答不评分

/*4*/ if(!(fp=fopen(\/*5*/ printf(\/*6*/ return; /*7*/ }

/*8*/ while((ch = fgetc(fp)) != EOF) { /*9*/ if(ch >= 'a' && ch <= 'z') /*10*/ ch += 'A'; /*11*/ putchar(ch); /*12*/ }

/*13*/ fclose(fp); /*14*/ }

5.9以下程序将字符串中的小写字母删除，并输出删除小写字母后的字符串结果。

/*1*/ #include

/*2*/ void main() {

/*3*/ char *str=\/*4*/ p=s=str; /*5*/ while(*s) {

/*6*/ if(*s >= 'a' && *s <= 'z')

/*7*/ for(p=s; *p; p++) *p = *(p+1); /*8*/ else s++;

/*9*/ }

/*10*/ while(*p; p++)

/*11*/ printf(\/*12*/ }

5.10以下函数inputx是输入k个整数到数组x中。 /* 1 */ void inputx(int x, int k) /* 2 */ { int i;

/* 3 */ for (i = 0; i < k; i++) /* 4 */ scanf(“%d”, &x++); /* 5 */ }

5.11.以下函数plink是输出首指针为head的链表中各结点的数据。 /* 1 */ struct node { int val;

/* 2 */ struct node *next; /* 3 */ }

/* 4 */ void plink(struct node head)

/* 5 */ { for ( ; head != NULL; head++) /* 6 */ printf(“?”, head.val); /* 7 */ }

5.12 函数sortTwo()的功能是使与函数的两个参数所对应的两个变量的值满足前一个不比后一个小的顺序。在函数发现它们不是要求的顺序时，函数就应该交换这两个变量的值，使

28--34 注：解答写在答卷纸上，试卷中的解答不评分

它们变成满足要求的顺序。

/* 1 */ void sortTwo(int x, int y) /* 2 */ { int t;

/* 3 */ if (x > y) {

/* 4 */ t = x; x = y; y = t; /* 5 */ } /* 6 */ }

5.13函数enters是将字符串s中的大写英文字母转换成小写英文字母，并返回字符串ｓ； /* 1 */ char *enters(char *s) /* 2 */ { char *t = s; /* 3 */ while ( t )

/* 4 */ { if (*t >= ‘A‘ | | *t <= ‘Z‘ ) /* 5 */ *t = *t + ‘a‘; /* 6 */ t++; /* 7 */ }

/* 8 */ return *s; /* 9 */ }

5.14 以下为采用“冒泡法”对数组进行升序排序的程序。 /* 1*/ #include

/* 2*/ #define N 6 /* 3*/ void main()

/* 4*/ int a[] = {0, 3, 1, 5, 4, 2}, i, j, t; /* 5*/ for(i=0; i

/* 6*/ for(j=0; j a[j+1]) {

/* 8*/ t = a[j]; a[j] = a[j+1]; a[j+1] = t; /* 9*/ }

/* 10*/ printf(“%d ”, a[i]); /* 11*/ } /* 12*/ }

5.15 以下语句定义了一个结构类型struct node和结构变量p，并赋值。 /*0*/ struct node {

/*1*/ char s[10]; int k; /*2*/ /*3*/ /*4*/ /*5*/

5.16 函数strUpToLow()把一个字符串中的大写字母变为小写字母，并返回结果。 /*1*/ char *strUpToLow(char *str) { /*2*/ char *p = str;

29--34 注：解答写在答卷纸上，试卷中的解答不评分

}

struct node p; p.s = “abc”; p.k = 2;

/*3*/ /*4*/ /*5*/ /*6*/ /*7*/

};

while(*str) {

if(*str>='A' || *str<='Z') *str = *str - 'A' + 'a'; str ++ ; }

return *str;

/*8*/

5.17函数digits(char *s)统计给定字符串s中数字字符的个数。

/* 1 */ void digits(char *s) /* 2 */ { int c = 0; /* 3 */ while(s){

/* 4 */ if(*s >= 0 || *s <= 9) c++; /* 5 */ s++; /* 6 */ } /* 7 */ return c; /* 8 */ }

5.18函数readArray(int a[ ], int n)为指定的数组输入n个数据。 /* 1 */ void readArray(int a[ ] int n) /* 2 */ { int k;

/* 3 */ printf(\ \/* 4 */ for(k = 0; k <= n; k++) /* 5 */ scanf(\/* 6 */ }

六、程序设计题

6.1输入正整数n，输出由n行2n-1列的等腰三角形图案，以下是n等于4的图案。 * * * * * * * * * * * * * * * *

6.2输入正整数n，输出由n行2n-1列的等腰三角形图案，以下是n等于4的图案。 * * * * * * * * * * * * * * * *

6.3试编写按以下公式计算π的函数：double pi(double epsilon)（直到最后一项小于由形参指定的epsilon为止）。 π 1 1 2 1 2 3 1 2 3 4

— = 1 + — + — * — + — * — * — + — * — * — * — + ?? 2 3 3 5 3 5 7 3 5 7 9

30--34 注：解答写在答卷纸上，试卷中的解答不评分

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