目             录
1.C语言基本概念
⑴  源程序格式、风格和结构。main函数特性。C程序保存。 注释位置。
⑵  基本类型数据的表示及使用
⑶  运算符和表达式的表示及使用
2.语句
⑴实现顺序结构的语句
⑵   实现选择结构的语句:  if-else，switch
⑶   实现循环结构的语句:   while，do-while，for，goto
⑷   跳转语句:  break，continue，return
3.构造类型数据
⑴   基本类型数组（一维，二维）
⑵   结构类型变量与数组
4.指针类型数据
⑴  基本类型变量的指针操作
(2)   基本类型数组的指针操作
(3)   结构类型变量、数组的指针操作
(4)  指针类型数组的声明和使用
5. 函数
⑴   函数定义、函数声明、函数调用
(2)   函数调用时基本类型实参的传递与使用。实参与形参的类型兼容性要求。实参类型的自动转换
(3)   函数调用时结构类型实参的传递与使用
(4)   函数调用时指针类型实参的传递与使用
(5)   函数返回值的产生
(6)   全局变量、局部变量与形式参数的作用域
(7)   局部变量、形式参数的存储类型和生存期
6. 函数高级应用
(1)  递归函数执行过程
(2)   函数的指针操作
(3) 返回指针类型值的函数
7. 单向链表
⑴   结点数据类型定义
⑵  使用malloc()函数,free()函数动态申请、释放结点存储区
⑶  基本操作：建立链表、遍历链表、查找结点、插入新结点、删除结点、数据统计、链表倒序
10. 文件操作
⑴   文件指针变量的声明（重点掌握）
⑵   缓冲文件系统常用操作函数的使用：
11. 综合
2.  数值计算算法
3.  非数值计算算法
(1)  穷举法找数
(2) 排序（冒泡法，插入法 ，选择法）
(3) 在数组中查找数据（线性法，折半法）
(4)  将一个数据插入有序数组中
(5) 删除数组中数据
(6)  多个数组数据合并
(7) 数据统计
(8) 其他（素数判断，回文数判断，回文判断，约瑟夫问题）
(9) 生成矩阵（杨辉三角形，…)
(10) 模拟十进制长整数算术运算
(11)字符串处理（子串替换，加密,¡­）

江苏省计算机等级考试
二级C语言
笔试辅导
笔试概况
•	考试时间：2小时
•	合格、优秀成绩要求
•	内容题型及分值
–	信息技术
    选择题（20分）C语言
    选择题（10分）
    填空题（30分）：简单填空（5分）                                    阅读程序（13分）                                  完善程序（12分）
•	答题策略
语法考试要求及考题解析
（2007秋~2010春）
1.C语言基本概念
⑴  源程序格式、风格和结构。main函数特性。C程序保存。 注释位置。
【考题解析】
[填空题]在一个C语言源程序中，必不可少的是             。
答案： main函数定义
[单选题].以下叙述中正确的是         。     
A．在编译时可以发现注释中的拼写错误
B．C语言程序的每一行只能写一条语句
C．main( ){  }必须位于程序的开始
D．C语言程序可以由一个或多个函数组成
 答案：D
  
[单选题]  在一个源程序中main函数的位置             。
     A．必须在最开始                        
     B．必须在最后
     C．必须在预处理命令的后面    
     D．可以在其他函数之前或之后
答案：D
[单选题]  下列叙述中正确的是              。   
A. main函数必须出现在其他函数之前
B. main函数中至少必须有一条语句
C. C程序总是从main函数的第一条语句开始执行
D. C程序总是在执行完main函数的最后一条语句后结束
答案： C                 

[单选题] 以下叙述中正确的是            。
A. C语言系统以函数为单位编译源程序
B. main函数必须放在程序开始
C. 用户定义的函数可以被一个或多个函数调用任意多次
D. 在一个函数体内可以定义另外一个函数
答案：C
[全国选择题] 以下叙述中正确的是（）。   
     A) C语言程序将从源程序中第一个函数开始执行
B)  可以在程序中由用户指定任意一个函数作为主函数，程序将从此开始执行 
C)  C语言规定必须用main作为主函数名，程序将从此开始执行，在此结束 
D)   main可作为用户标识符，用以命名任意一个函数作为主函数
答案：C 

[全国选择题] 以下叙述中正确的是 (  )  。
A) C程序中的注释只能出现在程序的开始位置和语句的后面。
B) C程序书写格式严格，要求一行内只能写一个语句
C) C程序书写格式自由，一个语句可以写在多行上
D) 用C语言编写的程序只能放在一个程序文件中
答案：C
[全国选择题] 以下叙述中正确的是(    )。 
A)C程序的基本组成单位是语句    
B)C程序中的每一行只能写一条语句
C)简单C语句必须以分号结束      
D)C语句必须在一行内写完
答案：C

⑵  基本类型数据的表示及使用
    ①  系统预定义类型标识符、类型修饰符的使用
    ②  基本类型常量的表示及使用 
    ③  字符串常量形式
    ④ 关键字。标识符。
    ⑤  符号常量的定义与使用 
    ⑥  基本类型变量的声明、初始化, 直接引用变量
【考题解析】
[单选题] 在C语言源程序中，不带任何修饰符的浮点数直接量（例如：3.14）都是按         类型数据存储的。  
答案： double
[单选题]已知sizeof(int)的值为2，为将10!的值存储到变量f中（10!=3628800），变量f的类型应声明为              。
A．long int	                      B．int              
C．short int                               D．unsigned  int
答案：A 

[单选题] 以下常量表示中正确的是     (22)      。  
           A. \xff	             B.5L	         C. aEb	    D. 3.14U
 答案：B
[单选题] 以下语句中有语法错误的是           。
printf("%d",0e);                     
B. printf("%f",0e2);  
C. printf("%d",0x2);                    
D. printf("%s","0x2");
 答案：A

[单选题]以下选项中不能用作变量名的是            。  
A．_float            B．switch          C．sum            D．_123 
答案： B    
[填空题]在C语言系统中，如果一个变量能正确存储的数据范围为整数-3276832767，则该变量在内存中占   (3)   个字节。
答案： 2 
[单选题]以下选项中，不能用作标识符的是       。
print	           B.  FOR            C.  &a        D.  _00
答案：C
[单选题] 以下选项中，            是C语言关键字。 
A． printf          B．include            
C．fun             D．default
答案：D
[学校单选题] 执行语句“printf(”bye\bye101\101“);”时输出到屏幕的结果为   (22)   。 
答案： byye101A 

[学校单选题]  表达式“1e-8/2+1.0f”值的数据类型是     (3)      。
int             B. long        C. float           D. double 
答案：D
[学校单选题]以下局部变量声明中正确的是      (2)      。  
int char=2;       B. void a=0;      
C. int a=b=0;         D. int a, b=a=0; 
答案：D

 ⑶  运算符和表达式的表示及使用
    ① 赋值表达式，赋值运算符的左值要求
    ②  算术表达式。++、--运算符左值要求。溢出。
    ③ 关系表达式与逻辑表达式，逻辑表达式优化处理
    ④ 逗号表达式
    ⑤ 条件表达式  
    ⑥ 表达式运算中操作数类型自动转换与强制转换
【 考题解析】  
[单选题] 若有声明“double x=3,c,*a=&x,*b=&c;”，则下列语句中错误的是         。 
A．a=b=0;               B．a=&c,b=a;        
C．&a=&b;             D．*b=*a;
答案：C 

[单选题] 若有声明“char ss[8]=”Red“;”，则sizeof(ss)的值是         。 
  A．8                  B．4           C．3                  D．1 
答案: A  
[单选题] 设有定义和声明如下： 
#define  d  2
int x=5;  float y=3.83;  char c='d';
以下表达式中有语法错误的是             。  
x++            B. y++        	C. c++              D. d++ 
答案：  D
[单选题]  数学式       在C程序中正确的表示形式为        。 
A．sqrt(a)/2*b                       B．sqrt(a)/2/b      
C．sqrt(a)/2b                         D．sqrt a/(2*b)
答案: B  

[单选题]  已知有声明“long x,y;”且x中整数的十进制表示有n位数字（4＜n＜10），若要求去掉整数x十进制表示中的最高位，用剩下的数字组成一个新的整数并保存到y中，则以下表达式中能正确实现这一功能的是          。
A. y=x/(10*(n-1))                       B. y=x%(10*(n-1))
C. y=x%(long)pow(10,n-1)      D. y=x%(10(n-1))
答案：C
[填空题] 若有声明“double x=10,y=5;”，则计算xy的库函数调用形式是          。
答案：   pow(x,y) 或 pow(10,5)
[填空题] 若有声明“int  x;”且sizeof(x)的值为2，则当x值为
                           时“x+1>x”为假。
答案：  32767

[填空题] 若有声明“float y=3.14619;int x;”，则计算表达式“x=y*100+0.5,  y=x/100.0”后y的值是           。
答案：  3.15  
[单选题]  已知有声明“int a=3,b=4,c;”，则执行语句“c=1/2*(a+b);”后，c的值为           。
    A. 0                B. 3                C. 3.5              D. 4 
答案：A
[填空题] 若有声明“int a=5,b=2;”，则表达式“b+=(float)(a+b)/2”运算后b的值为          。
答案：5
[填空题] 已知有声明“char  ch=‘g’;”，则表达式ch= ch-‘a’+‘A’的值为字符            的编码。
答案：G  

[单选题] 已有声明“int a=3,b=3,c=2;”，以下选项中值为0的表达式是             。     
!a&&!b&&c                     B. !a||!b||c        
C. a==b&&b>=c                  D. a>=b&&b>c  
答案: A 
[单选题] 已知有声明“int  a=3,b=4,c=5; ”，以下表达式中值为0的是            。
a&&b          B. a<=b          C. a||b&&c          D. !(!c||1)
答案：D
[填空题] C语言中有!、&& 、|| 三个逻辑运算符，其中优先级高于算术运算符的是           。
答案： ！
[单选题]  若有声明“int  x=2,y=1,z=0;”，则下列关系表达式中有语法错误的是           。
Ａ. x>y=2	    Ｂ.z>y>x	Ｃ. x>y==1	Ｄ.x==(x=0,y=1,z=2)
答案：A

[填空题] 数学式                  对应的C语言表达式为           。
答案：sqrt(fabs(x))!=4*a/(b*c)   或  
            sqrt(fabs(x))!=4*a/b/c 
[单选题] 已知有声明“int a=12,b=15,c;”，则执行表达式“c=(a||(b-=a))”后，变量b和c的值分别为             。
A．3.1         B．15,12         C．15,1            D．3,12
答案: C 
[填空题]  数学式           所对应的C语言表达式为pow(x,           )。
答案：1.0/3
[填空题]  若有声明“int a=15,b=20,c=25,e;”，则执行语句“e=a>b? --c :++c;”后变量e的值是          。
答案： 26

[单选题] 以下选项中，不能表示函数                                       功能的表达式是               。
A. s=(x>0)?1:(x<0)?-1:0         	    
B. s=x<0?-1:(x>0?1:0)
C. s=x<=0?-1:(x==0?0:1)         	    
D. s=x>0?1:x==0?0:-1
答案： C
[单选题]  若有程序段“char  c=256;   int  a=c;”，则执行该程序段后a的值是          。
256 		B. 65536	      C. 0	 D. -1
答案： C

[填空题] 设有声明“int a=3, b=4; float x=4.5, y=3.5;”，则表达式“(float)(a+b)/2+(int)x%(int)y”的值是            。
答案: 4.5     
[填空题]．若有声明“int r=2;”，则执行语句“printf(”%d“,sizeof(2*3.14*r));”时输出           。
答案：8
[单选题]  已知有声明“int n; float x,y;”，则执行语句“y=n=x=3.89;”后，y的值为           。
3                 B. 3.0                C. 3.89            D. 4.0
答案：B
[单选题]  已知有声明“int a=3,b=4;”，下列表达式中合法的是           。 
    A. a+b=7        B. a=|b|        C. a=b=0       D. (a++)++ 
答案：C
[学校单选题]  已知有声明“int a=1,b=2;”，执行语句
   “while(--a > 0&& --b>0)a=b;”后变量a、b的值是            。
0,2           B. 0,1              C. 1,1           D. 2,2
答案：A
2.语句
⑴实现顺序结构的语句
① 表达式语句，空语句，复合语句，函数调用语句
② 标准输入输出库函数printf(), scanf()，getchar() , putchar() ,gets(),puts()
【考题解析】 
[单选题] 已知int类型数据在内存中存储长度为2个字节，以下语句中能正确输出整数32768的是            。
printf("%d",32768);         B. printf("%ld",32768); 
C.   printf("%f",32768);            D. printf("%c",32768);
答案：B

[学校单选题]  已知某编译系统中sizeof(int)的值为2，在该编译系统中执行以下    (10)      语句时输出结果不是39999。     
A. printf("%u",39999);               B. printf("%d",39999);     
C. printf("%ld",39999);              D. printf("%lu",39999);
答案： B 
[单选题]  若有声明“float f=123.45678;”，则执行语句“printf( ”%.3f“,f );”后，输出结果是              。
Ａ. 1.23e+02      Ｂ. 123.457      Ｃ. 123.456780      Ｄ. 1.234e+02
答案： B 

[单选题] 已知有声明“char s[80];”，若需要将键盘输入的一个不含空格的字符串保存到s数组中，则下列语句中正确的是            。
scanf("%s",s);       B. scanf("%s",s[0]);    
C.   s=gets();                    D. s=getchar();
答案：A 
[填空题] 已知有声明和语句“int a;scanf(”a=%d“,&a);”，欲从键盘上输入数据使a中的值为3，则正确的输入应是        。
答案：a=3 
[单选题] 若有声明“long a,b;”且变量a和b都需要通过键盘输入获得初值，则下列语句中正确的是      。
scanf("%ld%ld,&a,&b");       
B.   scanf("%d%d",a,b);
C.   scanf("%d%d",&a,&b);           
D.   scanf("%ld%ld",&a,&b);
答案：D 

⑵   实现选择结构的语句:  if-else，switch
【考题解析】
[单选题] 若在一个C语言源程序中“e1”和“e3”是表达式，“s;”是语句，则下列选项中与语句“for(e1; ;e3)s;”功能等同的语句是          。
A. e1;while(10)s;e3;                 B. e1;while(10){s;e3;}
C. e1;while(10){e3;s;}               D. while(10){e1;s;e3;}
答案：B 
[单选题] 已知有声明“int x,y;”，若要求编写一段程序实现“当x大于等于0时y取值1，否则y取值-1”，则以下程序段中错误的是         。  
A. if(x>=0)y=1;else y=-1;       B. y=x>=0?1:-1;
C. switch()                               D. switch(x-abs(x))
{   case x>=0: y=1;  break;      {  case 0: y=1;  break;               
      default: y=-1;                        default: y=-1;
}                                                 }
答案：C  

[学校单选题] 已知有声明“int a=1,b=2,c=0;”，执行语句“if(a>b) c=a;a=b;b=c;”后变量a、b的值是    (21)   。
答案：  2,0

[阅读程序]  下列程序运行后的输出结果第一行是   (1)   ；第二行是   (2)   。    
#include <stdio.h>
main( )
{ int i,a=0,c=2;
  for(i=0;i<2;i++)
    switch(++a , a*c)
    { case 1: printf("1");
      case 2: printf("2");
      case 3: printf("3\n");break;
     default: printf("other\n");
    }
}
答案:  (1)   23   (2)  other

[阅读程序]  以下程序运行时输出结果为      (6)                    
      #include <stdio.h>
void  main()
{  int i,sum=0;
   for (i=0;i<5;i++)
   {  switch(i)
      {  case 0: 
         case 1: sum++;
         case 3: sum++;
         case 4: sum--; break;
      }
    }
    printf("%d\n",sum);
}
答案:    1 

⑶   实现循环结构的语句:   while，do-while，for，goto
【考题解析】 
[单选题] 若有声明“int i,k=1; unsigned j;”，则下列语句执行时会出现无限循环的语句是         。
Ａ.for(j=15;j>0;j-=2) k++;            
B. for(j=0;j<15;j+=2) k++;     
Ｃ.for(i=0;i<15;i+=2) k++;              
Ｄ.for(i=15;i>0;i-=2) k++;
答案:    A
[学校单选题] 以下语句中有语法错误的是            。
for(; ;);          B. do ; while(1);    
C.  while();           D. p: ; goto p; 
答案：C

[阅读程序] 以下程序运行时输出结果最后一行是       。 
           #include<stdio.h>
void main()
{   int a=1,b=1,i;
    for(i=1;i<=2;i++)
    {   a=a+b;
        printf("%d / %d , ",b,a); 
        b=a+b;
        printf("%d / %d \n",a,b);
     }
    printf("\n");
}
答案:   3/5，5/8  

[阅读程序] 以下程序运行时输出结果是            。
#include <stdio.h>
main()
{  int s=1,n=235;
   do
   {  s*=n%10;
       n/=10;
    }while(n);
   printf("%d\n",s);
}
答案：  30
⑷   跳转语句:  break，continue，return
【考题解析】 
[全国选择题] 有以下程序
    #include  <stdio.h>
   #include  <stdio.h>
    main()
    {  int x=8;
       for(;x>0;x--)
         {   if(x%3) {  printf("%d,", x--);continue;}
	         printf("%d,", --x );
         }
    }
    程序的运行结果是(    )。
    A) 7,4,2，    B) 8,7,5,2，    C) 9,7,6,4，   D) 8,5,4,2,
答案：D

3.构造类型数据
 ⑴   基本类型数组（一维，二维）
     ①  数组声明及初始化
     ② 数组存储结构
     ③  使用数组名引用数组元素 
【考题解析】 
[单选题] 以下声明中错误的是         。
A．int a[2];            B．int a[ ]={0,1};   
C．int a[3]=0;        D．int a[3][4]={0}; 
答案:  C
[全国单选题] 下列选项中，能正确定义数组的语句是（）。
  A）int num[0..2008] ;     B） int num[];
  C）int N=2008;               D)  #define N 2008
         int num[N];                        int num[N]; 
答案：D

[单选题] 设有声明“int p[10]={1,2},i=0;”，以下语句中与“p[i]=p[i+1],i++;”等价的是           。
A. p[i]=p[i++];                         B. p[++i]=p[i];
C. p[++i]=p[i+1];                     D. i++,p[i-1]=p[i];
答案：D  
[全国单选题] 已知有声明“int m[]={5,4,3,2,1},i=0;”，下列对m数组元素的引用中，正确的是           。
m[--i]      B)m[2*2]     C)m[m[0]]   D)m[m[i]]
答案：B

[填空题]  若有声明“char  s1[10]=″ABCDE″,s2[10]=″A\\0″;”，则语句
“printf(″%d″,strlen(strcpy(s1,s2)));”的输出结果是         。 
 答案： 3
[全国选择题]  有以下程序
 #include<stdio.h>
main()
{int a[5]={1,2,3,4,5},b[5]={0,2,1,3,0},i,s=0;
for(i=0;i<5;i++)s=s+a[b[i]];
printf("%d\n",s);
}
程序运行后的输出结果是（）：
  A）6          B）10          C）11         D) 15
答案：  C

[单选题] 已知有声明“char s[20]=”Hello“;”，在程序运行过程中，若要想使数组s中的内容修改为“Good”，则以下语句中能够实现此功能的是             。   
       A．s="Good";                           B．s[20]="Good";
       C．strcat(s,"Good");                D．strcpy(s,"Good");
答案：D

[单选题] 已知有声明“int a[4][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12},{13,14,15,16}};”，若需要引用值为12的数组元素，则下列选项中错误的是              。
       A．*(a+2)+3       B．*(*(a+2)+3)            C．*(a[2]+3)        D．a[2][3]
答案：A

[阅读程序] 以下程序运行时输出结果中第一行是    （1）    ，第三行是      （2）        。        
      #include <stdio.h>
#define  N  5 
void main()
{   static char a[N][N];   
     int i,j,t,start=0,end=N-1;
    char str[ ]="123",ch;
    for(t=0;t<=N/2;t++)
    {   ch=str[t];
        for(i=j=start;i<end;i++) a[i][j]=ch;
        for(j=start;j<end;j++) a[i][j]=ch;
        for(i=end;i>start;i--) a[i][j]=ch;
        for(j=end;j>start;j--) a[i][j]=ch;
        if(start==end) a[start][end]=ch;
        start++,end--;
    }    

  [阅读程序] 以下程序运行时输出结果的第一行是      (1)      ，第三行是     (2)           。        
      #include <stdio.h>
void main( )
{    int i,j,a[3][3];
     for(i=0;i<3;i++)
        for(j=0;j<3;j++) 
           if(i<j) 
                a[i][j]=1;
           else  
                a[i][j]=i-j+1;
     for(i=0;i<3;i++)
     {   for(j=0;j<3;j++)
             printf("%4d",a[i][j]);
         printf("\n");
      }
} 

 ⑵   结构类型变量与数组
     ①  定义结构类型
     ② 结构类型变量、数组声明及初始化
     ③ 用变量名引用结构变量（结构数组元素）的全体成员 
     ④ 用变量名引用结构变量（结构数组元素）的基本类型成员
【考题解析】 
[单选题]  若有结构类型定义
     “typedef  struct  test{ int x,y[2]; }TEST;”，则以下声明中正确的是    （27）    。
A．struct test x;                B．struct  x;  
C．test  x ;                         D．struct  TEST  x;
答案：A

[单选题]  以下结构变量stu1的声明形式中，错误的是          。
Ａ．typedef struct stu{char name[10];float score;}STU ;  
        STU stu1; 
Ｂ．#define STU struct stu 
         STU {char name[10];float score; }stu1;  
Ｃ．struct stu{char name[10];float score;}stu1; 
Ｄ．struct stu{char name[10];float score;}STU; STU stu1;
答案：D
[学校单选题]  若有定义
  “struct  c{ double x,y；}c1={1.2,1.3},c2={1.2,1.3},c3；
    struct  d{ double x,y；}d1={1.2,1.3},d2={1.2,1.3},d3；”,
   则以下表达式中正确的是       。   
c3=0           B.  c1==c2           C.  c3=c1         D.  d3=c1 
答案：C

[阅读程序] 以下程序运行后的输出结果第一行是   (1)   ；第二行是   (2)   。
#include <stdio.h>
struct num
{ int x,y ;
} st[ ]={{1,10},{2,20},{3,30},{4,40},{-1,-1}},s1[2],s2[2];
main()
{ int i=0,j=0,k;
  for(k=0; st[k].x != -1; k++)
  {   if(st[k].x%2)
         s1[i++]=st[k];
     else
        s2[j++]=st[k];
  }
  printf (" %d \n %d \n",s1[0].y ,s2[0].y );
}  
答案： (1)  10    (2)  20
4.指针类型数据
⑴  基本类型变量的指针操作 
      ①  基本类型变量地址的获取与保存。
     指向基本类型变量的指针变量声明、初始化与赋值。
      ② 引用指针变量指向的基本类型变量（使用运算符*）
【考题解析】
[填空题] 若有声明char *p="%d,%d\n";  int a=1,b=2;  
          则执行语句“printf(p,a,b);”时输出    (4)     。
答案：1,2
[全国选择题] 若有定义语句：double x,y,*px,*py,执行了px=&x, py=&y;之后，正确的输入语句是（）。
       A）scanf（”%f%f”,x,y）;                   
       B） scanf（”%f%f”,&x,&y）;
C） scanf（”%lf%le”,px,py）;           
       D） scanf（”%lf%lf”,x,y）;
答案：C     

 [全国 选择题]  有以下程序
#include<stdio.h>
main()
{   int m=1,n=2,*p=&m,*q=&n,*r;
    r=p;  p=q;  q=r;
    printf(“%d,%d,%d,%d\n”,m,n,*p,*q);
}
程序运行后的输出结果是
A)1,2,1,2       B)1,2,2,1      C)2,1,2,1      D)2,1,1,2
答案：B

[全国选择题] 有以下程序
#include<stdio.h>
#include<stdlib.h>
int fun(int n)
{   int *p;     
     p=(int *)malloc(sizeof(int));
    *p=n;       
      return  *p;
}
main()
{   int a;   a=fun(10);  printf(“%d\n”,a+fun(10));   }
程序的运行结果是（）。
0          B) 10          C) 20         D) 出错 
答案：C      
(2)   基本类型数组的指针操作 
    ①  基本类型数组元素地址的获取、保存与算术运算。
    ② 引用指针变量指向的基本类型数组元素
    ③ 二维数组行地址的获取、保存及算术运算。
    行指针变量的声明、初始化。 
    ④  引用行指针变量指向的基本类型数组元素
【考题解析】 
[单选题] 设指针变量占2个字节的内存空间，若有声明
“char *p=”123“;int c;”，则执行语句“c=sizeof(p);”后，c的值为          。
 A. 1                 B. 2               C. 3                D. 4   
答案: B
[全国选择题] 若有定义语句：
 double x[5]={1.0,2.0,3.0,4.0,5.0},*p=x;
则错误引用x数组元素的是（）。
*p         B)x[5]        C)*(p+1)    D)*x
答案：B

[单选题] 若有声明“int x[10]={0,1,2,3,4,5,6,7,8,9},*p;”，则值不为4的表达式是           。
A．p=x,*(p+4)                            B．p=x+4,*p++      
C．p=x+3,*(p++)                        D．p=x+3,*++p
答案: C
[单选题] 已知有程序段
 “char str[ ][10]={"Aoyun","Beijing"},
   *p=&str[0][0]; 
    printf("%s\n",p+10);”，
 则执行printf语句后输出为     。
A．Beijing     B．Aoyun        C．ing        D．ng 
答案: A

[单选题] 已知有声明“int i,a[10],*p=a;”，现需要将110保存到a[0]a[9]中，以下程序段中不能实现这一功能的是          。
for(i=0;i<10;i++) a[i]=i+1;               
B.   for(i=0;i<10;i++) p[i]=i+1;
C.   i=1;while(p<a+10) *p++=i++;            
D.   i=1;while(p<a+10) *a++=i++;
答案：D
[填空题] 已知有声明 
       “int a[3][2]={{1,2},{3,4},{5,6}},*p=a[0];”，则执行语句“printf(”%d\n“,*(p+4));”后的输出结果为         。
答案：5
[单选题] 若有声明“int a[3][4], *p=a[0] ,(*q)[4]=a;”，则下列叙述中错误的是           。 
Ａ. a[2][3]与q[2][3]等价           	Ｂ. a[2][3]与p[2][3]等价
Ｃ. a[2][3]与*(p+11)等价           	Ｄ. a[2][3]与p=p+11,*p等价
答案：B

 [单选题] 已知有声明
   “int a[3][3]={0},*p1=a[1],(*p2)[3]=a;”，以下表达式中与“a[1][1]=1”不等价的表达式是         。
A. *(p1+1)=1                           B. p1[1][1]=1       
C. *(*(p2+1)+1)=1                  D. p2[1][1]=1
答案：B
[填空题] 若有声明“char  s[10]=”remind“;”，执行“puts(s+2);”后的输出结果是            。
答案:   mind
[单选题] 已知有声明：
“char a[ ]="It is mine", *p="It is mine";”，
下列叙述中错误的是         。
  A. strcpy(a,“yes”)和strcpy(p,“yes”) 都是正确的
  B. a=“yes”和p=“yes”都是正确的
  C. *a 等于*p
  D. sizeof(a)不等于sizeof(p) 
答案：B

[全国完善程序] 以下程序的功能是：借助指针变量找出数组元素中的最大值所在数组元素的下标值。
#include<stdio.h>
main()
{  int a[10],*p,*s;
   for(p=a;p-a<10;p++)  
            scanf(“%d”,p);
   for(p=a,s=a;p-a<10;p++)
           if(*p>*s)  s=__________;
   printf(“index=%d\n”,s-a);
}
答案：p
(3)   结构类型变量、数组的指针操作 
 ①  结构变量地址、结构数组元素地址的获取与保存。
 指向结构变量指针变量的声明、初始化与赋值。 
②   引用指针指向的结构类型变量（结构类型数组元素）的基本类型成员
结构变量成员的地址、结构数组元素成员的地址获取与保存。
指向结构变量成员的指针变量声明、初始化与赋值。
 【考题解析】 

[单选题] 已知有结构定义和变量声明如下：
   struct student
   {  char name[20];
       int score;
       struct  student *h;
    }stu,*p;  int *q;
以下选项中错误的是          。
    A．p=&stu;                            
    B．q=&stu.score;      
    C．scanf("%s%d",&stu);               
    D．stu.h=p; 
答案: C 

[阅读程序] 以下程序运行时输出结果的第一行是   （1）     ，第二行是   （2）  
      #include <stdio.h>
struct s
{   int x,*y;
}*p;
int d[5]={10,20,30,40,50};
struct s
    a[5]={100,&d[0],200,&d[1],300,&d[2],400,&d[3],500,&d[4]};
void main( )
{  p=a;
   printf("%5d",p->x++);         printf("%5d\n",p->x);
   printf("%5d",*p->y);           printf("%5d\n",*++p->y);
} 
答案:   (1) 100   101     (2) 10    20 

[单选题] 设有结构定义及变量声明如下： 
struct product
{  char  code[5];
   float  price;
}y[4]={"100",100};
以下表达式中错误的是           。
A. (*y).code[0]='2';        B. y[0].code[0]='2'; 
C. y->price=10;              D. (*y)->price=10;
答案： D 
(4)  指针类型数组的声明和使用
【考题解析】
[全国单选题]  有以下程序
#include<stdio.h>
main()
{  char *a[ ]={"abcd","ef","gh","ijk"};
    int i;
    for(i=0;i<4;i++)
    printf("%c",*a[i]);
}
程序运行后输出的结果是
A）aegi         B）dfhk       C）abcd       D）abcdefghijk
答案：A
[全国单选题] 若有定义语句：int a[4][10],*p,*q[4];且0<=i<4,则错误的赋值是（）。
A)  p=a      B)  q=a        c) q[0]=a         D)p=&a[2][1]
答案：B

[全国填空题]  有以下程序
#include<stdio.h>
main()
{ int a[]={1,2,3,4,5,6},*k[3],i=0;
  while(i<3)
  {  k[i]=&a[2*i];
      printf("%d",*k[i]);       i++;
 }
}
程序运行后的输出的结果是___________  
答案：135
5. 函数 
⑴   函数定义、函数声明、函数调用
(2)   函数调用时基本类型实参的传递与使用。实参与形参的类型兼容性要求。实参类型的自动转换
【考题解析】
[单选题] 以下函数定义中正确的是     （25）    。
A. double fun(double x,double y){ }    
B. double fun(double x;double y){ }
C. double fun(double x,double y);{ }   
D. double fun(double x,y){ }
 答案：A

[单选题]  以下选项均为fun函数定义的头部，其中错误的是        。
A. int fun(int x,int y[ ])                B. int fun(int x,int y[x])
C. int fun(int x,int y[3])               D. int fun(int x,int *y)
答案：B
[学校单选题] 已知函数fun定义的头部为“void fun(int x, int y[])”，以下fun函数声明中正确的是             。
void  fun(int x,int y[ ]);             B.  void  fun(int x, int  *y);
void  fun(int ,int);                      D.  void  fun(int ,int  * );
答案：C
[单选题]  若有声明
“long  fun(int *x,int n,long *s);int a[4]={1,2,3,4}; long b,c;”，则以下函数调用形式中正确的是            。
A. c=fun(a,4,b);                     B. c=fun(a[ ],4,&b);
C. c=fun(a[4],4,b);                D. c=fun(a,4,&b);
答案：D

[单选题] 若函数调用时的实参为变量，则以下关于函数形参和实参的叙述中正确的是           。
A. 实参和其对应的形参占用同一存储单元
B. 形参不占用存储单元
C. 同名的实参和形参占用同一存储单元
D. 形参和实参占用不同的存储单元
答案：D 
[全国选择题]  函数调用语句func(f2(v1,v2),(v3,v4,v5),(v6,max(v7,v8))); 中func函数的实参个数是（）。
   A)3          B)4          C)5         D)8
答案：A

[阅读程序] 以下程序运行时输出结果是             。 
          #include <stdio.h>
void func(int b)
{  int  a;  
   a=b;     b=10; 
 }
void main()
{   int a=10,b=20;
    func(b);    
    printf("%d,%d",a,b);
} 
答案: 10,  20 

[阅读程序] 以下程序运行时输出到屏幕的结果是          。
   #include <stdio.h>
   void swap(int a,int b)
   {  int t;
      if(a>b)t=a,a=b,b=t;
   }
   void main()
   {  int x=13, y=11, z=12; 
      if(x>y) swap(x,y);
      if(x>z) swap(x,z);  
      if(y>z) swap(y,z);
      printf("%d\t%d\t%d\n", x,y,z);
   }
答案：8． 13   11    12

[阅读程序] 以下程序运行时输出结果是      。
     #include<stdio.h>
int f(int x, int y)
{  return  x+y;  }
void main()
{  double a=5.5, b=2.5;
   printf("%d",f(a,b));
} 
答案：  7

[阅读程序] 以下程序运行后的输出结果是           。
#include <stdio.h>
int fun(int w1 , int w2)
{  return w2-w1; 
}
main( )
{  int w=1,k ;
   k=fun(fun(w+1,w),w) ;
   printf("%d\n",k) ;
}
答案：2

[全国选择题] 有以下程序
#include<stdio.h>
void fun(int a , int b)
{  int t;
   t=a;  a=b;  b=t;
}
  main()
  {  int c[10]={1,2,3,4,5,6,7,8,9,0},i ;
     for(i=0;i<10;i+=2) fun(c[i],c[i+1]);
     for(i=0;i<10;i++) printf(“%d,”,c[i]);
     printf(“\n”);
   }
   程序的运行结果是（）
  A) 1,2,3,4,5,6,7,8,9,0,                      B) 2,1,4,3,6,5,8,7,0,9,
  C) 0,9,8,7,6,5,4,3,2,1,                      D) 0,1,2,3,4,5,6,7,8,9,
答案：A
(3)   函数调用时结构类型实参的传递与使用
[阅读程序] 以下程序运行时输出到屏幕的结果第一行是   (1)     ，第二行是   (2)     。
#include <stdio.h>
typedef struct { int x,y; }direction;
int visible(direction s,direction A,direction B,direction C)
{  direction p1,p2;      int d;
   p1.x=B.x-A.x;       p1.y=B.y-A.y;
   p2.x=C.x-A.x;       p2.y=C.y-A.y;
   d = s.x*p1.x*p2.x + s.y*p1.y*p2.y;
   printf("%4d\n", d);
   return d>0;
}
void main( )
{  char *ss[]={"invisible","visible"};
   direction s={1,1},T={1,1},A={0,0},B={2,1};
   puts(ss[visible(s,T,A,B)]);
}
答案： (1)  -1   (2)   invisible
(4)   函数调用时指针类型实参的传递与使用
【考题解析】
[单选题] 若需要通过调用f函数得到一个数的平方值，以下f函数定义中不能实现该功能的是         。
   A. void  f(double *a){ *a=(*a)*(*a);}
   B. void  f(double a,double *b){ *b=a*a; }
   C. void  f(double a,double b){ b=a*a;}
   D. double  f(double a){ return  a*a; } 
答案： C

[全国选择题]  有以下程序
#include <stdio.h>
void fun（ int *a,int *b）
{  int *c;
   c=a;  a=b; b=c;
}
main（）
{  int x=3,y=5,*P=&x,*q=&y;
   fun（p,q）;
        printf（”%d,%d,”,*p,*q）;
   fun（&x,&y）;
       printf（”%d,%d\n”,*p,*q）;
}
程序运行后的输出结果是
A）3,5,5,3      B）3,5,3,5      C）5,3,3,5      D）5,3,5,3 、
答案：B

[阅读程序] 以下程序运行时输出结果是      。
      #include <stdio.h>
void change(int x, int y, int *z)
{   int t;
    t=x; x=y; y=*z; *z=t;
}
void main( )
{   int x=18,y=27,z=63;
    change(x,y,&z);
    printf("x=%d,y=%d,z=%d\n",x,y,z);     
} 
答案：  x=18, y=27, z=18

[全国选择题]  有以下程序
#include<stdio.h>
  void fun(int a[], int n)
  {   int i,t;
      for(i=0;i<n/2;i++){t=a[i];a[i]=a[n-1-i];a[n-1-i]=t;}
  }
  main()
  {   int k[10]={1,2,3,4,5,6,7,8,9,10},i;
      fun(k,5);
      for(i=2;i<8;i++) printf(“%d”,k[i]);
      printf(“\n”);
   }
  程序的运行结果是
  A) 345678    B) 876543     C)  1098765     D) 321678
答案：D

[阅读程序] 以下程序运行时输出结果中第一行是   （1）  ，第二行是  （2）   
#include<stdio.h>
void fun(int x,int p[],int *n)
{  int i,j=0;
   for(i=1;i<=x/2;i++)
        if(x%i==0)  p[j++]=i;
   *n=j;
}
void main()
{    int x,a[10],n,i;
     fun(27,a,&n);   
   /*  调用fun函数将27的所有因子保存到a数组，因子个数保存到n*/
     for(i=0;i<n;i++)
         printf("%5d",a[i]);
       printf("\n%5d",n);
} 
答案:     (1)1 3 9    (2) 3 

[阅读程序] 以下程序运行时输出结果中第一行是    （1）    ，第二行是    （2） 
     #include<stdio.h>
int fun(char *a,char *b)
{  int m=0,n=0;
   while(*(a+m)!='\0')m++;
   while(b[n])
   {  *(a+m)=b[n];m++;n++;  }
   *(a+m)='\0';
   return m;
}
void main()
{  char s1[20]="yes",s2[5]="no";
   printf("%d\n",fun(s1,s2));
   puts(s1);
} 
答案：(1) 5   (2) yesno 

[阅读程序] 以下程序运行时输出到屏幕的结果第一行是     (1)      ，第二行是     (2)      。
#include <stdio.h>
void fun(char *p1,char *p2);
void main()
{   int i;   char a[]="54321";
    puts(a+2);
    fun(a,a+4);
    puts(a);
}
void fun(char *p1,char *p2)
{   char  t;
    while(p1<p2)
    {  t=*p1;*p1=*p2;*p2=t;
       p1+=2,p2-=2;
    }
} 
答案： (1)  321    (2)  14325

[完善程序] 以下程序的功能是：求a数组中前4个元素之和及后6个元素之和。
      #include<stdio.h>
       int fsum(int *array,int n)
{   int i,s=0;         
    for(i=0;     （1）    ; i++)            
       s+=array[i];
    return(s); 
} 
void main(void)
{   int a[15]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
    int sumh,sumt;
    sumh=fsum(a,4);    
    sumt=     （2）     ;       
    printf(“%d %d\n”,sumh,sumt);
} 
答案:    (1)  i<n     (2)   fsum(&a[9], 6)     或   fsum(a+9, 6)

(5)   函数返回值的产生 
【考题解析】
[填空题] 已知有函数定义“int fun(){return (3,4);}”，则调用fun后的函数返回值是   （1）     。
答案:  4  
 [全国选择题] 以下叙述中错误的是（）。
A)用户定义的函数中可以没有return语句
B)用户定义的函数中可以有多个return语句，以便可以调用一次返回多个函数值
C)用户定义的函数中若没有return语句，则应当定义函数为void类型
D)函数的return语句中可以没有表达式
答案：B

[全国选择题] 以下关于return语句的叙述中正确的是（）。
  A）一个自定义函数中必须有一条return语句
  B）一个自定义函数中可以根据不同的情况设置多条return语句
  C）定义成void类型的函数中可以有带返回值的return语句
  D) 没有return语句的自定义函数在执行结束语句时不能返回到调用处  
答案：B
(6)   全局变量、局部变量与形式参数的作用域 
【考题解析】 
[阅读程序]  以下程序运行时输出结果是             。 
#include <stdio.h>
int t;
int sub(int *s)
{   *s+=1; 
    t+=*s;
    return  t;
}
main()
{  int  i;
   for(i=1;i<4;i++)
      printf("%4d",sub(&i));
}
答案： 2  6
(7)   局部变量、形式参数的存储类型和生存期
【考题解析】  
[单选题] 已知在函数f中声明了局部变量x，如果希望f函数第一次被调用返回后变量x中存储的数据保持到下次f函数被调用时仍可以使用，则在声明x时必须指定其存储类型为   （30）   。
    A. auto              B. register             C. static            
    D. extern
答案：C
[填空题] 声明局部变量时若缺省存储类别，该变量的存储类别是           。
答案：auto
[填空题]  可以改变局部变量的生存期、但不能改变它的作用域的存储类别是         。
答案：static

[阅读程序] 以下程序运行时输出结果的第一行是  (1)   ，第二行是  (2)      。                          
             #include<stdio.h>
int  f1( )
{   static  int i=0,f=1;  
    return   f*=++i;  
}
int  f2( )  
{   int i=0,f=1;
    return f*=++i;  
}
void main( )   
{   printf("%d\n",f1( )+f1( )); 
    printf("%d\n",f2( )+f2( ));  
}
答案:   (1) 3    (2) 2 

[阅读程序]  以下程序运行时输出到屏幕的结果第一行是     (1)      ，第二行是     (2)       ，第三行是     (3)       。
#include  <stdio.h>
int g(int x,int y)
{   return x+y ;  }
int f(int x,int y)
{     {  static int x=2;
          if(y>2)
          {  x=x*x;          y=x       }
           else y=x+1;
        }
        return x+y;
}
void main( )
{  int  a=3;
   printf("%d\n",g(a,2));
   printf("%d\n",f(a,3));
   printf("%d\n",f(a,2));
}
答案：(1) 5       (2) 7     (3) 8
6. 函数高级应用
(1)  递归函数执行过程 
【考题解析】 
[阅读程序] 以下程序运行时输出结果是   （8）     。 
#include<stdio.h>
void  f(long x)
{  if(x<100)  printf("%d", x/10);
   else  {  f(x/100);    printf("%d", x%100/10); }
}
main()
{   f(123456);  } 
答案：  135

[阅读程序]  以下程序运行后的输出结果第一行是   (13)   。
#include <stdio.h>
void print(int n);
void print_n(int n);
main()
{   print(4); }
void print(int n)
{  if (n==0) return;
   print_n(n);
   if (n>0) print(n-1);
 }
void print_n(int n)
{  if(n==0)return;
   printf("%d",n);
   if(n>1) print_n(n-1);
   else	 printf("\n");
}
答案：4321 
[阅读程序]  以下程序运行时输出结果是          .            
      #include<stdio.h>
#include<string.h>
void  sf(char *s1,char *s2)
{   if(*s1=*s2)  
      sf(s1+1,s2+1);  
}
void main( )
{   char a[20]= "ABC",b[20]="xyz";  
    sf(a+strlen(a),b);  
    puts(a);  
} 
答案:  ABCxyz 

[阅读程序] 以下程序运行时输出结果是         . 
      #include <stdio.h>
#include <ctype.h>
int count(char s[])
{  int i=0;
   if(s[i]=='\0') return 0;
   while(isalpha(s[i])) i++;
   while(!isalpha(s[i])&&s[i]!='\0') i++;
   return  1+count(&s[i]);        /* 递归调用 */
}
void main()
{  char line[]="one world,one dream.";
   printf("%d",count(line));
} 
答案： 4 

[阅读程序]  以下程序运行时输出到屏幕的结果是             。
#include <stdio.h>  
void fun(int m,int n)
{  if(m>=n)
      printf("%d",m);
   else
      fun(m+1,n);
   printf("%d",m);
}
void main( )
{  fun(1,2);  }
答案：221

(2)   函数的指针操作 
    ① 函数地址的获得及保存。指向函数的指针变量声明、初始化、赋值
    ② 调用指针变量指向的函数 
【考题解析】
[全国填空题]  请将以下程序中的函数声明语句补充完整
#include <stdio.h>
int  _________________;
main( )
{  int x,y,(*p)();
   p=max;
   printf(“&d\n”,(*p)(x,y));
}
int max(int a,int b)
{   return (a>b/a:b);  } 
答案 ：max(int a,int b)   或     max(int ,int )

[全国选择题]  设有以下函数：
void fun(int n,char *s) {…….}
则下面对函数指针的定义和赋值均正确的是
A)     void  (*pf)();  pf=fun;
B)     void  *pf();     pf=fun;
C)     void  *pf();     *pf=fun;
D)     void  (*pf)(int,char *);  pf=fun;
答案 ：D
[学校单选题] 若已有如下程序： 
#include<math.h>
double g(double a,double (*p)(double))
{    return p(a)*p(a); } 
 main()
{    double x=2,y;        /* g函数调用语句位置 */     }
现需要在main函数中调用g函数，以下选项中正确的g函数调用语句是         。
A． y=g(x,exp);                   B． y=g(x,exp(x));    
C． y=g(x,exp());                D． y=g(double x, double exp);
答案：A 
(3) 返回指针类型值的函数
    以下程序运行结果是（）。
#include<stdio.h>
#include<stdlib.h>
int * fun(int n)
{   int *p;
     p=(int *)malloc(sizeof(int));
    *p=n+10;       return  p;
}
main()
{   int *p;
     p=fun(10);  printf(“%d\n”,*p);
} 
答案：20
7. 单向链表
  ⑴   结点数据类型定义
  ⑵  使用malloc()函数,free()函数动态申请、释放结点存储区 
  ⑶  基本操作：建立链表、遍历链表、查找结点、插入新结点、删除结点、数据统计、链表倒序

建立链表关键操作
   需声明指针变量：head（指向链表首结点），p1（指向新申请结点），p2（指向链表末结点）
      while(仍有数据需保存到链表)
{   p1=(struct node *)malloc(sizeof(struct node));
    p1->成员名=数据;
    if(head==0) 
       head=p2=p1;
    else	
    {  p2->next=p1;  p2=p1;  }
}
p2->next=NULL;             
return head;
遍历链表(输出结点数据，统计结点数据)关键操作
    需声明指针变量p或直接用形参
      p=head;（指向链表首结点）
while(p!=NULL)
{  查找结点数据、输出结点数据、统计结点数据
   p=p->next;
} 
插入结点到链表关键操作
     需声明指针变量：p（指向待插入新结点），head（指向链表首结点）,p1（指向插入位置之前结点），p2（指向插入位置之后结点）
  ① 申请新结点并保存数据到结点
p=(struct node *)malloc(sizeof(struct node));
p->成员=数据;  
p->next=NULL;
  ② 若要求将新结点插入链表第一个结点前
if(head==NULL)head=p
else { p->next=head; head=p; }
return head;

③ 若要求将新结点插入有序链表中
     if（新结点应插入到链表首结点之前）
{  p->next=head;  head=p;  return head;  }
     else
{   p1=head;   p1指向链表第一个结点
          p2=head->next;  p2指向链表第二个结点
        while（p2!=NULL）
   {   if ( 新结点应插入到p2指向结点之前) 立即终止循环
              else  { p1=p2;p2=p2->next; }
   }
         if(p2==NULL)p1->next=p;  新结点添加到末结点之后
         else {p->next=p2; p1->next=p;} 新结点插入p2指向结点之前
}
      return  head;
从链表中删除结点关键操作
    需声明指针变量：head（指向链表首结点），p1（指向需删除结点之前结点），p2（指向需删除结点）
      if(首结点需要删除，即head->成员=给定值)
{  p=head;   head=head->next;  或head=p->next;   free(p);  }
     else
{   p1=head;               p1指向链表第一个结点
          p2=head->next;     p2指向链表第二个结点
         while(p2!=NULL）
  {
           if(p2指向结点需删除)立即终止循环
     else {  p1=p2;  p2=p2->next; }
        }
        if p2==NULL)  
  {    puts(“not found”);   }  未找到结点
        else 
        {   p1->next=p2->next;  free(p2); }  删除p2指向结点
     }  
    return head;    
【考题解析】  
插入新结点   
[完善程序] 以下程序的功能是：函数struct node * insert(struct node *head, struct node *p)将p指向的结点作为首结点插入head指向的链表中。main函数接收从键盘输入的一行字符，每接收一个字符后，申请一个新结点保存该字符，并调用insert函数将新结点插入链表中。最后从表头开始依次输出该链表各结点成员c的值。试完善程序以达到要求的功能。 
      #include <stdio.h>
#include <stdlib.h>
struct node
{  char c;
   struct node *next;
};  

void main( )
{  struct node *insert(struct node *head, struct node *p);
   char ch;   struct node *head,*p;     head=NULL;
   while((ch=getchar( ))!='\n')
   {  p=(struct node *)malloc(sizeof(struct node));
           （1）     =ch;      
        p->next=NULL;
           （2）      ;         
   }
   p=head;
   while(p!=NULL)
   {  printf("%c",p->c);
           （3）      ;       
   }
}
struct node * insert(struct node *head, struct node *p)
{  if(head==NULL)      head=p;        
   else    {       （4）      ;         head=p;   }
   return head;
 }
答案: (1)p->c  (2)head=insert(head,p)  (3)p=p->next;  (4)p-next=head 

数据统计
[完善程序] 以下程序创建一个链表并实现数据统计功能。函数WORD *create(char a[][20],int n)创建一个包含n个结点的单向链表，结点数据来自a指向的数组中存储的n个单词（字符串）。函数void count(WORD *h)统计h指向的单向链表中不同单词各自出现的次数，将统计结果保存到局部数组c中并输出。 （2009春）
    程序运行时输出结果为   “red:1  green:2  blue:3”。
     #include "stdio.h"
#include "stdlib.h"
#include "string.h"
typedef struct w
{  char word[20];
   struct w *next;
}WORD;

    WORD *create(char a[][20],int n)
{  WORD *p1,*p2,*h=0; int i;
   for(i=0;i<n;i++)
   {  p1=(WORD *)malloc(sizeof(WORD));
      strcpy(     (1)     ,a[i]);
      if(h==0) 
         h=p2=p1;
      else	
        {  p2->next=p1;  p2=p1;  }
   }
   p2->next=       (2)       ;             
   return h;
} 
答案： (1)  p1->word   (2)  0或NULL 

void count(WORD *h)
{  struct
   {  char word[20];      int num;   }c[6]={0};
   int m=0,i;
   while(h)
   {  if(m==0)
      {  strcpy(c[0].word,h->word);      c[0].num=1;  m++;      }
      else
      {  for(i=0;i<m;i++)
             if(strcmp(c[i].word, h->word)==0)
             {           (3)         ;    
                 break;
              }
             if(i>=m)
         {  strcpy(c[m].word,h->word);      c[m++].num=1;       }
      }
              (4)         ;                
   }
   for(i=0;i<m;i++)   printf("%s: %d   ",c[i].word,c[i].num);
} 
答案:   (1)  c[i].num++    (2)  h=h->next 

void main()
{  char words[6][20]={"red","green","blue","blue",
         "green","blue"};
   WORD *head=0;
   head=create(words,6);
   count(head);
  } 

查找、删除结点
[完善程序] 设h1和h2分别为两个单链表的头指针，链表中结点的数据结构为：
typedef struct node
      {  int data;
         struct  node *next;
      }NODE;
sea_del函数的功能是：删除h1指向的链表中首次出现的与h2指向的链表中数据完全匹配的若干个连续结点,函数返回h1指向链表的头指针。
例如，初态下，h1指向链表和h2指向链表如下图所示：

NODE *sea_del(NODE *h1,NODE *h2)
{  NODE *p,*ph,*q,*s;
   ph=NULL;   p=q=h1;   s=h2;
   if(h1==NULL||      (1)      )  return h1;
   while(p!=NULL&&s!=NULL)
   { while(q->data==s->data&&q&&s)
     {  q=q->next;
        s=      (2)      ;               
      }
     if(s!=NULL)  /*失配时,h1起始结点后移, h2从首结点开始*/
         {  ph=p;
            p=q=p->next;
            s=      (3)      ;             
         }
     else 
       if(ph==NULL)  h1=q;
       else  ph->next=q;
    }
         (4)      ;                  
}   
    答案： (1)  h2==NULL或 h2==0     (2)   s->next   
                 (3)  h2                                    (4)   return h1

查找、删除、插入结点
[完善程序] 设一个单向链表结点的数据类型定义为：
struct node
{   int x;   
    struct node *next;
  };
     fun函数从h指向的链表第二个结点开始遍历所有结点，当遇到x值为奇数的结点时，将该结点移到h链表第一个结点之前，函数返回链表首结点地址。print函数输出p指向的链表中所有结点的x值。程序运行后的输出结果是“1  3  4  2”。

     #include<stdio.h>
#define N 4
struct node
{  int x;   
    struct node *next; 
};
void  print(struct node *p)
{    while(    (1)     )               
	 {  printf("%4d",      (2)     );  p=p->next;}
     printf("\n");
}
答案：  (1)  p      (2)  p->x 

     struct node *fun(struct node *h)
{  struct node *p1,*p2,*p3;
   p1=h; p2=p1->next;
   while(p2)
   {  if(p2->x%2)
      {  p3=p2;  
         p1->next=     (3)    ;   
         p2=p1->next;        
         p3->next=h;    
              (4)      ;                
     }
     else
      {   p1=p2;    p2=p2->next;   }
   }
  return h;
}

链表倒序
设某单向链表结点的数据结构定义为:
typedef struct node
{  char ch;
   struct node *next ;
} linklist ;
    以下程序首先建立一个单向链表head（如图1所示），该链表每个结点中保存x数组的一个元素值;  输出head链表中每个结点的值;再将head链表变换为倒序链表（如图所示），输出倒序后head链表中每个结点的值。 

#include <stdio.h>
typedef struct node
{  char ch;
   struct node *next;
}linklist ;

     linklist *revlist( linklist *head)
{   linklist *hp,*p=NULL; 
hp=head; 
head=     (29)     ;                              
    while(hp)
    {   p=hp; 
        hp=hp->next;
        p->next=head;                      
                (30)       ;           
    }
    return head;
}

8. 枚举类型数据   
 ⑴   枚举类型定义
 ⑵   枚举变量的命名、声明
 ⑶   枚举常量的使用
 ⑷   枚举变量的赋值及使用
【考题解析】 
[填空题]若已有定义“enum TP{A,B,C};”，则执行语句“printf(”%d\n“,A+1);”后输出结果是      (3)     。
答案: 1    
[单选题].若有枚举类型定义“enum 	list1{x1,x2,x3,x4=6,x5,x6};”，则枚举常量x2和x6代表的值分别是           。
A. 1，6 	B. 1，8	C. 2，6 	D. 2，8
答案: B    

9.     预处理命令  
 ⑴    #define命令
 (2)    #include命令
【考题解析】
[填空题]  C语言有效的预处理命令总是以   (4)   开头。
答案：  #
[填空题]执行以下程序段中的语句“k=M*M+1;”后k的值是    (4)     。
#define  N  2
#define  M  N+1
 k=M*M+1; 
答案：  6 

[阅读程序]  以下程序运行后的输出结果是        。
#include <stdio.h>
#define  Count(n)  ++n
main ( )
{  int x=-3 ,n=8;
   while(Count(x)) n--;
   printf("%d\n",n);
}
答案：  6

[阅读程序] 以下程序运行时输出到屏幕的结果为            。
#include<stdio.h>
#define  MAX(A,B)  A>B ? 2*A : 2*B
void main()
{  int a=1,b=2,c=3,d=4,t;
   t=MAX(a+b,c+d);
   printf("%d\n",t);
} 
答案：10
[阅读程序] 以下程序运行时输出结果是      (5)      。   
#define  EVEN(x)  x%2==0?1:0
main()
{     if(EVEN(5+1)) printf("Even");
	   else	 printf("Odd");
}
答案： Odd

[全国选择题] 以下叙述中错误的是(    )。  
A)在程序中凡是以“#”开始的语句行都是预处理命令行
B)预处理命令行的最后不能以分号表示结束
C)#define  MAX是合法的宏定义命令行
D)C程序对预处理命令行的处理是在程序执行的过程中进行的
答案：D

10. 文件操作    
 ⑴   文件指针变量的声明（重点掌握）
 ⑵   缓冲文件系统常用操作函数的使用：
    fopen(),fclose()，fprintf(),fscanf(),fgetc(),fputc(),fgets(),fputs(),
    feof (),rewind(),  fread(),fwrite()，fseek()  
【考题解析】 
[填空题] 已知某程序中有预处理命令“#include<stdio.h>”，为使语句“zx=fopen(”c:\\a.txt“,”r“);”能正常执行，在该语句之前必须有声明             。
答案:    FILE *zx;
[填空题] 若需要打开D盘上user子目录下已经存在的名为abc.txt的文本文件,先读出文件中数据，后追加写入新数据，则正确的函数调用语句是：
“fp=fopen("D:\\user\\abc.txt",             ); ”。
答案:  "a+“

[单选题]  已知A盘根目录下有文本文件“data.txt”且程序中已有声明“FILE *fp;”，若程序需要先从“data.txt”文件中读出数据，修改后再写入“data.txt”文件中，则调用fopen函数的正确形式是      (28)     。
A.   fp=fopen("a:\\data.txt","rw");        
B.   fp=fopen("a:\\data.txt","w+");
C.   fp=fopen("a:\\data.txt","r+");	        
D.   fp=fopen("a:\\data.txt","r"); 
答案:  C 
[单选题]  下列叙述中，正确的是            。
A．C语言中的文件是流式文件, 只能顺序存取文件中数据
B．调用fopen函数时若用“r”或“r+”模式打开一个文件，该文件必须在指定存储位置或默认存储位置处存在。
C．当对文件进行了写操作后，必须先关闭该文件然后再打开，才能读到该文件中的第1个数据。
D．无论以何种模式打开一个已存在的文件，在进行了写操作后，原有文件中的全部数据必定被覆盖。
答案:  B 

[全国选择题] 有以下程序   
    #include  <stdio.h>
    main()
    {  FILE *fp；int a[l0]={1,2,3},i,n;
        fp=fopen("d1.dat","w");    ．
        for(i=0; i<3;i++) fprintf(fp,"%d",a[i]);
        fprintf(fp,"\n");
        fclose(fp);
        fp=fopen("d1.dat","r");
        fscanf(fp,"%d",&n);
        fclose(fp);
       printf("%d\n",n);
    }
 程序的运行结果是(    )。 
    A)12300         B)123        C)1        D)321
答案：B

[阅读程序] 以下程序运行时输出结果是     .
     #include <stdio.h>
void  main()
{  double x[3]={1.1,2.2,3.3},y;   
   FILE *fp=fopen("d:\\a.out","wb+");
   fwrite(x,  sizeof(double),3,fp);
   fseek(fp,  2L*sizeof(double),  SEEK_SET);
   fread(&y,sizeof(double),1,fp);
   printf("%.1f",y);
   fclose(fp);
} 
答案： 3.3 
11. 综合
[单选题] 在下列C语言源程序的错误中，通常不能在编译时发现的是     （21）      。     
A. 括号不匹配                        B. 非法标识符    
C. 数组元素下标值越界        D. 程序结构不完整
答案： C
[单选题] 以下定义和声明中，语法均有错误的是 （21）  。
① int  _f(int x){ }        ② int f(int f){ }    
③ int 2x=1;                 ④ struct  for{int x;};
②③       B. ③④        	C. ①④      D. ①②③④
答案： B

[单选题] 若程序中已有相应的声明，下列语句中错误的是       。
Ａ．printf(i==4 ? "%6d\n" : "%6d" , i );
Ｂ．i==4 ? printf("%6d\n",i ) : printf("%6d" , i ) ;
Ｃ．for (i=10 ; ; i--) if(i==1) break;
Ｄ．for (i=10 ; ; ) if(i--); break; 
答案： D  

[全国填空题] 以下程序的输出结果是_______
#include<stdio.h>
main()
{  int j,a[]={1,3,5,7,9,11,13,15},*p=a+5;
   for(j=3; j; j--)
   {  switch(j)
      {  case  1:
         case  2:  printf(“%d ”,*p++); break;
         case  3:  printf(“%d ”,*(--p));
      }
   }
}
答案：9  9  11

[阅读程序]以下程序运行时输出结果中第一行是   （1）    ，第二行是   （2）   ，第三行是   （3）    。
#include<stdio.h>
main()
{  int i,j,a[3][3]={0};
   for(i=0;i<3;i++)
    for(j=0;j<3;j++)
      switch(i-j+2)
      {  case 0: case 1: a[i][j]=1;break;
	        case 2: a[i][j]=2;break;
	        case 3: a[i][j]=3;break;
	        case 4: a[i][j]=5;break;
      }
  for(i=0;i<3;i++)
  {  for(j=0;j<3;j++)   printf("%4d",a[i][j]);
     printf("\n");
  }
}  
答案： (1)  2  1  1     (2)  3  2  1     (3)  5  3  2
算法考试要求及考题解析
（2007秋~2010春）
 1.   基本操作：交换，累加，累乘  
 【考题解析】 
交换数据
[阅读程序] 以下程序运行时输出到屏幕的结果是     (7)      。 
#include  <stdio.h>
void main( )
{  int  a=1,b=2;
   a+=b;
   b=a-b;
   a-=b;
   printf("%d,%d\n",a,b);
}
答案： 2,1

2.  数值计算算法  
  (1)  求若干整数的最大公约数
  (2) 求一个十进制表示整数的反序数
  (3) 一元非线性方程求根（牛顿迭代法，半分区间法）
  (4) 定积分计算（梯形法，矩形法）
  (5) 级数计算（递推法）
  (6) 矩阵转置， 矩阵乘法
 【考题解析】 

求最大公约数
[完善程序] 以下程序求一组整数的最大公约数。
#include<stdio.h>
int gcd(int a,int b)
{  int r;
   while(     (1)      )               
   {  r=a%b;  a=b;        (2)     ; }       
   return a;
}
void main()
{  int x,i,a[6]={12,56,48,32,16,24};
   x=     (3)       ;                      
   for(i=1;i<6;i++)
      x=gcd(      (4)      ,a[i]);         
   printf("(%d,",a[0]);
   for(i=1;i<5;i++) 
      printf("%d,",a[i]);
   printf("%d)=%d\n",a[5],x);
} 
答案:   (1)  b!=0   (2) b=r   (3) a[0]       (4)  x

求一个十进制字符串表示整数的反序数
[阅读程序] 以下程序运行后的输出结果是    (10)    。
#include <stdio.h>
main ( )
{  char a[ ]="369",*p=a;
   int s=0,t=1;
   while(*++p) t*=10;
   p--;
   while (t)
   {    s+=(*p-'0')*t;	
        p--;	 
        t/=10; 
}
   printf ("%d\n",s);
}
答案：963

一元非线性方程求根（牛顿迭代法）
[阅读程序] 用牛顿迭代法求方程3x3-3x2+x-1=0在2.0附近的一个实根，精度要求为10-5。函数F求f(x)的值，函数F1求f(x)的一阶导数值。 牛顿迭代公式如下：

     #include<stdio.h>
#include<math.h>
float  F(float x)
{  return  x*(3*x*(x-1)+1)-1;   }
float  F1(float x)
{  return 9*x*x-6*x+1;  }
float newtoon(float x)
{  float f,f1,x0;
   do 
    {            (1)      ;         
         f=F(x0);
         f1=F1(x0);
         x=       (2)      ;         
   }while(fabs(x-x0)>1e-5);
   return x;
}   

级数计算（递推法）
[完善程序] 以下程序通过给出的公式计算的近似值，计算过程在所加项的值小于10-10时终止。 

3.  非数值计算算法
    (1)  穷举法找数
    (2) 排序（冒泡法，插入法 ，选择法）
    (3) 在数组中查找数据（线性法，折半法）
    (4)  将一个数据插入有序数组中
    (5) 删除数组中数据
    (6)  多个数组数据合并
    (7) 数据统计         
    (8) 其他（素数判断，回文数判断，回文判断，约瑟夫问题）
    (9) 生成矩阵（杨辉三角形，…)
    (10) 模拟十进制长整数算术运算
    (11)字符串处理（子串替换，加密,¡­） 
  【考题解析】 

穷举法找数
[阅读程序] 寻找具有下列特性的四位正整数，其百位数为0，去掉百位数0可得到一个三位正整数，而该三位正整数乘以9等于原四位正整数。例如，6075＝675×9，所以6075是具有上述特性的正整数。
#include<stdio.h>
int fun(int n)
{   int a[4],i,k;
    k=n;
    for(i=0;k>0;i++)
    {   a[i]=     (1)     ;                
         k/=10;        
    }
    if(     (2)     &&(a[3]*100+a[1]*10+a[0])*9==n )    return 1;   
    else    return 0;
}

穷举法找数
[完善程序] 某餐厅用苹果、桔子、香蕉、菠萝、梨五种水果制作水果拼盘，要求每个拼盘中恰有三种不同水果。以下程序的功能就是计算可以制作出多少种这样的水果拼盘并列出组合方式。
#include <stdio.h>
typedef enum { apple,orange,banana,pineapple,pear } Fruit;
main()
{     (1)     fruits[ ]={"apple","orange","banana","pineapple","pear"};  
   Fruit x,y,z,p;
   int k=0,i;
   for (x=      (2)     ;x<=pear;x++)
     for (y=x+1;y<=pear;y++)
       for (z=y+1;z<=pear;z++)    
            printf ("\n%d %s %s %s ",++k, fruits[x],fruits[y],fruits[z]);
}  
答案： (1)  char *   (2)  apple或0

排序： 下标为奇数的数组元素排序，选择法 
[阅读程序] 以下程序运行时输出结果是               .
      #include <stdio.h>
void sort(int a[],int n)  
{  int i,j,p; int t;
   for(i=1;i<n-1;i+=2)  
   {     p=i;
         for(j=i+2;j<n;j+=2 )  
         if(a[j]>a[p])   p=j;     
         if(p!=i)
        {  t=a[i]; a[i]=a[p]; a[p]=t;  }
     }     } 
      void main( )
{   int s[ ]={8,1,4,3},n=4,k;
    sort(s,n);
    for(k=0;k<n;k++)  printf("%4d",s[k]);
    printf("\n");
} 
答案:       8 3 4 1 

排序 （选择法）  
[完善程序]以下程序对二维数组a中存储的NN矩阵做如下操作：先将每一行中值最大的元素与该行位于主对角线处的元素交换值，然后对主对角线上的所有元素排序使其自左上角到右下角升序排列，最后输出排序后主对角线上各元素的值。试完善程序以达到要求的功能。 

      #include <stdio.h>
#define N 5
void fun(int x[][N],int n)
{  int i,j,t,arr,col;
   for(i=0;i<n;i++)
   {  arr=x[i][0];  col=0;
      for(j=0;j<n;j++)
        if(x[i][j]>=arr)
         {  arr=x[i][j];           (1)       ;          }      
        t=x[i][i];             (2)      ;     x[i][col]=t;  
   }
   for(i=0;i<n-1;i++)
     for(j=i+1;j<n;j++)
       if(      (3)      )                         
       {   t=x[i][i];   x[i][i]=x[j][j];   x[j][j]=t ;  }        
   }
void main()
{  int a[N][N]={{10,25,24,13,23},{11,22,12,21,14},
                 {20,15,19,16,18},   {17,9,4,5,3},{2,1,6,7,8}},i;
   fun(a,N);    
   for(i=0;i<N;i++) printf("%3d",a[i][i]);
 } 
答案： (1) col=j    (2)x[i][i]=x[i][col]    (3) x[i][i]>x[j][j] 

结构数组排序：按成员x值升序，x值相同的按成员y值升序
    [阅读程序] 以下程序运行时输出结果中第一行是    (1)   ，第二行是   (2)   第三行是   (3)    .

     #include<stdio.h>
typedef struct 
{   int x;int y;  }S;
void fun(S pp[],int n)
{  int i,j,k;  S t;
   for(i=0;i<n-1;i++)
   {  k=i;
      for(j=i+1;j<n;j++)
  if((pp[j].x<pp[k].x)||(pp[j].x==pp[k].x&&pp[j].y<pp[k].y)) 
          k=j;
      if(k!=i)
      {  t=pp[i];  pp[i]=pp[k];  pp[k]=t; }
   }   
}     

 二维数组数据变换：最小值所在行与最后一行数据交换，最大值所在列与最后一列数据交换
  [阅读程序]  以下程序运行后的输出结果第一行是  (1)   ；第二行是  (2)  ；第三行是  (3)   。
#include <stdio.h>
void sot( int a[3][3])
{   int i,j,i0,j1,min,max,temp;
    min=max=a[0][0];
    for(i=0;i<3;i++)
    {  for( j=0;j<3;j++)
       {  if(a[i][j]<=min)
              { min=a[i][j];i0=i;}
           if(a[i][j]>=max)
              { max=a[i][j];j1=j;}
       }
   }

  for(j=0;j<3;j++)
  {  temp=a[i0][j]; 	 
     a[i0][j]=a[2][j];	 
     a[2][j]=temp;  
  }
  for(i=0;i<3;i++)
  {  temp=a[i][j1];  	 
     a[i][j1]=a[i][2];    
     a[i][2]=temp;  
  }

排序
[完善程序]下列程序的功能是对a数组a[0]～a[n-1]中存储的n个整数从小到大排序。排序算法是：第一趟通过比较将n个整数中的最小值放在a[0]中，最大值放在a[n-1]中；第二趟通过比较将n个整数中的次小值放在a[1]中，次大值放在a[n-2]中；……，依次类推，直到待排序序列为递增序列。试完善程序以达到要求的功能。

#include <stdio.h> 
#define N 7
void sort(int a[], int n)
{  int i,j,min,max,t;
   for(i=0;i<      (1)       ;i++)       
   {          (2)        ;                  
      for(j=i+1;j<n-i;j++)       
         if(a[j]<a[min])min=j;
         else if(a[j]>a[max])max=j;
      if(min!=i)              
         {  t=a[min];a[min]=a[i];a[i]=t;  }
      if(max!=n-i-1)
         if(max==i)   {  t=a[min];a[min]=a[n-i-1];a[n-i-1]=t;  }
         else      {  t=a[max];a[max]=a[n-i-1];a[n-i-1]=t;  }
   }
}  答案：(1)  n/2   或  n-i   或  n-i-1    (2)min=max=i

void main( )
{  int a[N]={8,4,9,3,2,1,5},i;
   sort(a,N);    printf("sorted:\n");   for(i=0;i<N;i++) printf("%d\t",a[i]);
   printf("\n");
}

字符串排序
[完善程序]程序运行时输出结果第一行   (1)    第二行是    (2)     。
#include<stdio.h>
#include<string.h>
void fun(char str[][20],int n)
{   int i,j,k;      char s[20];
    for(i=0;i<n-1;i++)
     { k=i;
       for(j=i+1;j<n;j++)
         if(strcmp(str[j],str[k])<0) k=j;
         strcpy(s,str[i]);          strcpy(str[i],str[k]);       strcpy(str[k],s);
    }
}
main( )
{   char str[6][20]={"PASCAL","BASIC","FORTRAN","C","COBOL","Smalltalk"};    int i;
    fun(str,6);        for(i=0;i<6;i++) printf("%s\n",str[i]);
}  答案：(1)  BASIC    (2)  C

删除数组中满足给定条件的所有数据
[阅读程序] 以下程序运行时输出结果的第一行是   （1）     ；第二行是   （2）     。 （删除数组中所有偶数）
#include <stdio.h>
int fun(int *x,int n)
{  int i,j;
   for(i=j=0;i<n;i++)
      if(*(x+i)%2)    *(x+j++)=*(x+i);
   return j;
}     
main()
{   int a[10]={1,5,2,3,8,3,9,7,4,10},n,i;
    n=fun(a,10);
    for(i=0;i<n;i++)
    {   printf("%5d",a[i]); 
        if((i+1)%3==0) printf("\n");
    }
}  
答案： (1)  1   5   3      (2)  3   9   7   

数组数据合并
[阅读程序] 以下程序运行时输出结果的第一行是    (1)    ；第二行是   (2)    ；第三行是  (3)     。
#include <stdio.h>
#define N 10
int merge(int a[],int b[],int c[],int m[][N+1])
{ int i=0,j,k;
  while((k=m[0][i])!=2)
  {   j=m[1][i];
	  if(k==0)   c[i]=a[j];
      else   c[i]=b[j];
	  i++;
  }
  return i;
}

main( )
{   int a[N]={1,3,5},b[N]={2,4,6},c[2*N],i,n;
	  int m[2][N+1]={ {0,1,0,1,0,1, 2}, {0,0,1,2,2,1,-1}};
    n=merge(a,b,c,m);
    printf("%d\n",n);
    for(i=0;i<n;i++)
    {  printf("%d  ",c[i]);
       if((i+1)%3==0)printf("\n");
     }
} 
答案： (1)  6           (2)  1  2  3        (3)  6  5  4

在数组中查找数据
[阅读程序] 以下程序运行时，若在键盘上输入 2<Enter>，则输出是  (1)  ；若在键盘上输入i<Enter>，则输出是    (2)    。    
     #include <stdio.h>
#include <string.h>
int  strch( char *s,char ch)
{  int i;
   for(i=strlen(s);i>=0;i--)
     if(s[i-1]==ch) return i;
   if(i<0)return  0;
}

约瑟夫问题：n个人报数，报到3的人出列，剩下人继续报数，直到所有人出列为止 ，显示依次出列人编号 
[阅读程序] 以下程序运行时若输入8，则输出结果中第一行是   （1）  ，第二行是    (2)    ，第三行是  （3） 。
      #include <stdio.h>
void main( )
{  int k,i,m,n,num[20];   scanf("%d",&n);
   for(i=0;i<n;i++)  num[i]=i+1;
   i=k=m=0;
   while(m<n-1)
   {  if(num[i]!=0)    k++;
      if(k==3)
      {   printf("%4d",num[i]);    num[i]=0;      k=0;   m++;
          if(m%3==0)   printf("\n");
      }
      i++;
      if(i==n)  i=0;
    }
   i=0;     while(num[i]==0)   i++;
   printf("%4d",num[i]);
}    答案:  (16) 3   6   1       (17) 5   2   8       (18) 4   7

生成矩阵（杨辉三角形）
[阅读程序] 以下程序运行时输出到屏幕的结果第二行是      (1)      ，第四行是     (2)      。        
#include <stdio.h>
#define N  6
void main()
{  int i, j, a[N+1][N+1];
   for(i=1;i<=N;i++)
   {  a[i][i]=1;a[i][1]=1; }
   for (i=3; i<=N; i++)
      for(j=2;j<i; j++)
         a[i][j]=a[i-1][j-1]+a[i-1][j];
     for(i=1; i<=N; i++)
     {   for(j=1; j<=i; j++)
          printf("%4d", a[i][j]);
       printf("\n");
     }
}
答案:  (1)  1  1              (2)   1  3  3  1

模拟十进制长整数算术运算
[完善程序]以下程序完成两个长正整数的加法运算并输出计算结果。函数add模拟手工加法运算的过程，将a和b指向的数组中存储的两个以字符串形式表示的n位正整数相加，并将运算结果以字符串形式保存到c指向的数组中。main函数中p1和p2数组分别存放被加数字符串和加数字符串，p3数组存放运算结果字符串。若p1中的字符串为"1000000001"、p2中的字符串为"9000000009"，调用add函数后p3得到的是以字符串表示的这两个整数相加的结果"10000000010"。试完善程序以达到要求的功能。 

      #include "stdio.h"
#include "string.h"
void add(char a[],char b[],char c[],     (1)       )  
{  int i,k;
   c[n]='\0'; k=0;
   for(i=n-1;i>=0;i--)
   {  c[i]=(a[i]-'0')+(b[i]-'0')+k;
      k=       (2)        ;         
      c[i]=c[i]%10+'0';
   }
   if(k)
   {  for(i=n+1;i>0;i--)
           c[i]=     (3)        ;
      c[i]=k+'0';
   }
}  答案:  (1)  int n     (2) c[i]/10      (3)  c[i-1] 

     void main()
{  char p1[80]="1000000001",p2[80]="9000000009",p3[80];
   int i,x=strlen(p1),y=strlen(p2);
   if(x<y)
   {  for(i=x;i>=0;i--)
      {  p1[i+y-x]=p1[i];  p1[i]='0';  }
           (4)     ;         
   }  
   if(x>y)
     for(i=y;i>=0;i--)
     {  p2[i+x-y]=p2[i];  p2[i]='0'; }
   add(p1,p2,p3,x);     
   puts(p3);
} 答案:  (4)  x=y

字符串处理：加密
[完善程序] 以下程序中函数replace的功能是：将字符串s中所有属于字符串s1中的字符都用s2中的对应位置的字符替换。假如s为“ABCBA”，s1为“AC”，s2为“ac”，则调用replace函数后，字符串s的内容将变换为“aBcBa”。试完善程序以达到要求的功能。 

      #include <stdio.h>
#define MAX 20
void replace(char *s, char *s1, char *s2)
{  char *p;
   for(; *s; s++)
   {  p=s1;
      while(*p&&     （1）      ) p++;    
      if(*p)  *s=      （2）      ;        
   }
}
void main( )
{  char s[MAX]="ABCBA",s1[MAX]="AC", s2[MAX]= "ac"; 
            （3）      ;             
      printf("The string of s is:");
      printf("%s\n", s);
} 
答案:   (1)  *p!=*s       (2)   *(s2+p-s1)     (3)  replace(s, s1, s2) 

字符串处理：数据统计
[完善程序] 统计一个字符串中数字字符“0”到“9”各自出现的次数，统计结果保存在数组count中。例如，如果字符串为“1enterschar4543123564879ffgh”，则统计结果为: 1:2  2:1  3:2  4:3  5:2  6:1  7:1  8:1  9:1。
#include <stdio.h>
void fun(char *t,int count[])
{   char *p=t;
    while(    (1)     )       
      {  if(*p>='0'&&*p<='9')   count[       (2)      ]++;    
         p++;
      }
}
void main()
{  char s[80]="1enterschar4543123564879ffgh";  int count[10]={0},i;
   fun(s,count);
   for(i=0;i<10;i++)
     if(count[i])  printf("%d:%d  ",i,count[i]);
}  答案： (1)  *p    或  *p!=‘\0’  或  p[0]!=‘\0‘   (2) *p-'0'或  p[0]-'0'

数据统计
[完善程序] 程序功能：选票统计。二维数组s中保存了投票后10张有效选票上所填写的候选人姓名，结构数组stat中保存统计结果。程序运行后的输出结果是“liu:2  wang:5  zhao:3”。
#include<stdio.h>
#include<string.h>
typedef struct
{   char name[20];    /* 候选人姓名 */
int count;                 /* 候选人得票数 */
}COUNT;

int count(char x[][20],int n,     (1)     )       
{  int i,j,k=0;
   for(i=0;    (2)    ;i++)
   {   for(j=0;j<k;j++)
       if(strcmp(st[j].name,x[i])==0)
       {     (3)    ;         break;    }
       if(j>=k)
       {       (4)     ;        st[k].count++;    k++;    }
   }
   return k;
}
main()
{ char s[10][20]={"liu","wang","zhao","zhao","wang","liu","wang","zhao","wang","wang"};
  COUNT stat[5]={0};      int i,n;    
  n=count(s,10,stat);
  for(i=0;i<n;i++)  printf("%s:%d\t",stat[i].name,stat[i].count);
}  答案：(1)  COUNT st[]    或 COUNT  *st   (2)  i<n   
                (3)  st[j].count++     (4)  strcpy(st[k].name, x[i])

字符串处理：子串替换
[完善程序] 下列程序中函数find_replace的功能是：在s1指向的字符串中查找s2指向的字符串，并用s3指向的字符串替换在s1中找到的所有s2字符串。若s1字符串中没有出现s2字符串，则不做替换并使函数返回0，否则函数返回1。试完善程序以达到要求的功能。
#include <stdio.h>
#include <string.h>
int find_replace(char s1[],char s2[],char s3[])
{   int i,j,k,t=0;   char temp[80];
    if(s1[0]=='\0'||s2[0]=='\0') return t;
    for(i=0;s1[i]!='\0';i++)
    {   k=0;    j=i;
        while(s1[j]==s2[k]&&s2[k]!='\0')
        {   j++;  
                 (1)      ;      
        }
答案： (1)  k++        

        if(s2[k]=='\0')
        {   strcpy(temp,&s1[j]);         
                     (2)       ;   
            i=i+strlen(s3);         
                     (3)       ;   
            t=1;
        }
    }
    return t;
}
void main()
{  char line[80]="This is a test program and a test data.";
   char substr1[10]="test",substr2[10]="actual";     int k;
   k=find_replace(line,substr1,substr2);
   if(      (4)       )       puts(line);
   else     printf("not found\n");
}
        答案： (2)  strcpy(&s1[i],s3) 或strcpy(s1+i,s3)   
               (3)  strcpy(&s1[i],temp) 或strcpy(s1+i,temp)
               (4)  k   或   k==1   或   k!=0   或  k>0

字符串处理：数字字符串转换为整数
[完善程序] 以下程序中函数long fun(char *str)的功能是：自左至右取出非空字符串str中的所有数字字符，将这些数字字符组成一个不超过8位的十进制整数并输出。例如，字符串str为“efg32gh76.jbejing08t5y4u2”，程序输出：32760854。
     #include <stdio.h>
long fun(char *str)
{  int i=0; long k=0;
   char *p=str;
   while(*p!='\0'&&    (1)   )         
   {  if(*p>='0'&&*p<='9')
      {  k=   (2)   +*p-'0';    
         ++i;   
       }
            (3)   ;                     
   }
   return k;
}

补充：回文数判断
[完善程序]  以下程序输出6位整数中的所有回文数。若一个整数等于它自身的反序数，则称该整数为回文数。例如，123321是回文数。
#include <stdio.h>
int main()
{  long x,y=0,i;
   for(i=100000;i<=999999;i++){
     x=i; 
           (1)     ;          
      while(x>0) {
         y=y*10+x%10;
	             (2)      ;      
      }
      if(i==y)
	printf("\t %ld",i);
  }
   return 0;
}   答案:  (1) y=0    (2)  x=x/10