一、选择题

（1）下列数据结构中，按先进后出原则组织数据的是
　　A）线性链表    B）栈
　　C）循环链表    D）顺序表
（2）具有3个结点的二叉树有
　　A）2种形态    B）4种形态
　　C）7种形态    D）5种形态
（3）设有下列二叉树：
　　对此二叉树前序遍历的结果为
　　A）ZBTYCPXA    B）ATBZXCYP
　　C）ZBTACYXP    D）ATBZXCPY
（4）结构化程序设计主要强调的是
　　A）程序的规模   B）程序的效率
　　C）程序设计语言的先进性  D）程序易读性
（5）程序的3种基本控制结构是
　　A）过程、子过程和分程序  B）顺序、选择和重复
　　C）递归、堆栈和队列   D）调用、返回和转移
（6）下列叙述中，不属于测试的特征的是
　　A）测试的挑剔性   B）完全测试的不可能性
　　C）测试的可靠性   D）测试的经济性
（7）需求分析中开发人员要从用户那里了解
　　A）软件做什么   B）用户使用界面
　　C）输入的信息   D）软件的规模
（8）下列关系模型中，能使经运算后得到的新关系中属性个数多于原来关系中属性个数的是
　　A）选择    B）连接
　　C）投影    D）并
（9）下列叙述中，正确的是
　　A）用E-R图能够表示实体集间一对一的联系、一对多的联系和多对多的联系
　　B）用E-R图只能表示实体集之间一对一的联系
　　C）用E-R图只能表示实体集之间一对多的联系
　　D）用E-R图表示的概念数据模型只能转换为关系数据模型
（10）“年龄在18～25之间”这种约束是属于数据库当中的
　　A）原子性措施   B）一致性措施
　　C）完整性措施   D）安全性措施
（11）以下说法错误的是
　　A）高级语言都是用接近人们习惯的自然语言和数学语言作为语言的表达形式
　　B）计算机只能处理由0和1的代码构成的二进制指令或数据
　　C）C语言源程序经过C语言编译程序编译之后生成一个后缀为.EXE的二进制文件
　　D）每一种高级语言都有它对应的编译程序
（12）算法是指为解决某个特定问题而采取的确定且有限的步骤，下面不属于算法的五个特性的是
　　A）有零个输入或多个输入
　　B）高效性
　　C）有穷性
　　D）确定性
（13）已知int a=6; 则执行a+=a-=a*a;语句后，a的值为
　　A）36
　　B）0
　　C）-24
　　D）-60
（14）下面各选项中，均是C语言标识符的选项组是
　　A）forchinato
　　B）long_123short56_do
　　C）voidunion_342
　　D）text.txt _023_3ew
（15）下列表达式中，结果为5的是
　　A）6*5%6
　　B）5*-2+15
　　C）5+75%10
　　D）6+-2/3
（16）下列常量中，为不合法的实型常量表示的是
　　A）.0032
　　B）0.0
　　C）0.3242E8
　　D）.E3
（17）关于C语言的主函数描述正确的是
　　A）C程序可以有多个main函数
　　B）C程序必有一个而且只能有一个main函数
　　C）C程序可以没有main函数
　　D）C程序的执行不一定在main函数开始执行
（18）已知int a=1,b=-1;则语句printf（"%d＼n",（a--,++b））;的输出结果是
　　A）-1
　　B）0
　　C）1
　　D）语句错误
（19）已知int a,b;double c;则以下语句中错误的函数调用是
　　A）scanf（"%d,%x,%lf",&a,&b,&c）;
　　B）scanf（"%d,%d,%le",&a,&b,&c）;
　　C）scanf（"%o,%x,%o",&a,&b）;
　　D）scanf（"%d,%o,%e",&a,&b,&c）;
（20）已知x,y,z均为整型变量，且值均为1，则执行语句++x||++y&&++z;后，表达式x+y的值为
　　A）1
　　B）2
　　C）3
　　D）4
（21）若int k=8;则执行下列程序后，变量k的正确结果是
　　main（）
　　{int k=8;
　　switch（k）
　　{case 9:k+=1;
　　case 10:k+=1;
　　case 11:k+=1;break;
　　default:k+=1;}
　　printf（"%d＼n",k）;}
　　A）12
　　B）11
　　C）10
　　D）9
（22）若int i,j;，则for（i=j=0;i<10&&j<8;i++,j+=3）控制的循环体执行的次数是
　　A）9
　　B）8
　　C）3
　　D）2
（23）下列程序的输出结果是
　　#include "stdio.h"
　　main（）
　　{ int i=6;
　　while（i--）
　　printf（"%d",--i）;
　　printf（"＼n"）;}
　　A）531
　　B）420
　　C）654321
　　D）死循环
（24）阅读下列程序，则执行结果是
　　#include "stdio.h"
　　main（）
　　{int a=0,b=0,c=0,i;
　　 for（i=0;i<4;i++）
　　switch（i）
　　{case 0:a=i++;
　　case 1:b=i++;
　　case 2:c=i++;
　　case 3:i++;}
　　printf（"%d,%d,%d,%d＼n",a,b,c,i）;}
　　A）0,1,3,4
　　B）1,2,3,4
　　C）0,1,2,5
　　D）0,2,3,4
（25）下面程序的运行结果是
　　#include "stdio.h"
　　main（）
　　{int j,i,k=0;
　　for（j=50;j<=60;j++）
　　{if（!（k%10））printf（"＼n"）;
　　for（i=2;i<j;i++）if（!（j%i））break;
　　if（i>=j-1）{printf（"%d",j）;
　　k++;}}}
　　A）5359
　　B）5953
　　C）3595
　　D）9535
（26）已知char ch=′C′；则以下表达式的值是
　　ch=（ch>=′A′ && ch<=′Z′）?（ch+32）:ch;
　　A）A
　　B）a
　　C）Z
　　D）c
（27）以下描述错误的是
　　A）C程序中，函数可以直接或间接的调用自己
　　B）函数调用时，函数名必须与所调用的函数名字完全一致
　　C）函数说明语句中的类型必须与函数返回值的类型一致
　　D）实参数可以与形参个数不一致
（28）阅读下面程序，则执行后的结果为
　　#include "stdio.h"
　　main（）
　　{fun3（fun1（）,fun2（））;}
　　fun1（）
　　{ int k=20;
　　return k;}
　　fun2（）
　　{ int a=15;
　　return a;}
　　fun3（int a,int b）
　　{int k;
　　k=（a-b）*（a+b）;
　　printf（"%d＼n",k）;}
　　A）0
　　B）184
　　C）175
　　D）编译不通过
（29）阅读下面程序，则执行后的输出结果为
　　#include "stdio.h"
　　fun（int a,int b）
　　{int s;
　　s=a*b/2;
　　printf（"%d＼n",s）;}
　　main（）
　　{int a=10,b=16;
　　fun（a,b）;}
　　A）10
　　B）16
　　C）160
　　D）80
（30）阅读下面程序，则程序执行后的结果为
　　#include "stdio.h"
　　main（）
　　{int a=4,b=6,c=7;
　　double d,fun（int,int,int）;
　　d=fun（a,b,c）;
　　printf（"%lf＼n",d）;}
　　double fun（int a,int b,int c）
　　{double s;
　　s=a%b*c;
　　return s;}
　　A）27
　　B）27.000000
　　C）28
　　D）28.000000
（31）下列不合法的指针变量的定义是
　　A）int *_k;
　　B）char *_245;
　　C）int *p;
　　D）double *5_is
（32）下列关于指针变量赋空值的说法错误的是
　　A）当赋空值的时候，变量指向地址为0的存储单元
　　B）赋值语句可以表达为变量名=′＼0′；
　　C）赋值语句可以表达为变量名=0；
　　D）一个指针变量可以被赋空值
（33）阅读下面程序，则执行后输出的结果为
　　#include "stdio.h"
　　void fun（int *a,int *b）
　　{int m;
　　m=（*a+*b）*（*a+*b）;
　　m+=（*a-*b）*（*a-*b）;
　　printf（"%d＼n",m）;}
　　main（）
　　{ int a=5,b=6,*x=&a,*y=&b;
　　 fun（x,y）;}
　　A）120
　　B）121
　　C）122
　　D）123
（34）阅读下面程序，则输出结果是
　　#include "stdio.h"
　　void fun（int *a,int *b）
　　{int c=20,d=25;
　　*a=c/3;
　　*b=d/5;}
　　main（）
　　{ int a=3,b=5;
　　fun（&a,&b）;
　　printf（"%d,%d＼n",a,b）;}
　　A）6,5
　　B）5,6
　　C）20,25
　　D）3,5
（35）以下对一维数组c进行正确的定义初始化的语句是
　　A）int c［10］=0;
　　 B）int c［10］={0}*10;
　　C）int c［1］={0,0,0,0,0,0,0};
　　D）int c［10］={0};
（36）以下二维数组c的定义形式是
　　A）int c［3］［］
　　B）float c［3,4］
　　C）double c［3］［4］
　　D）float c（3）（4）
（37）阅读下列程序，则执行后输出的结果是
　　#include "stdio.h"
　　int k=1;
　　main（）
　　{fun（k）;
　　printf（"%d＼n",k）;}
　　fun（int k）
　　{ k++;
　　 k=k*6;}
　　A）1
　　B）2
　　C）6
　　D）12
（38）已知#define M 2；的宏定义，执行语句k=M*5;后，k的值是
　　A）10
　　B）5
　　C）2
　　D）以上答案都不对
（39）已知：int c［3］［4］;则对数组元素引用正确的是
　　A）c［1］［4］
　　B）c［1.5］［0］
　　C）c［1+0］［0］
　　D）以上表达都错误
（40）现有如下程序段
　　#include "stdio.h"
　　void fun（int *a,int *b,int *c）
　　{*c=*a+*b;}
　　main（）
　　{int a［2］={12,23},c;
　　fun（a,a+1,&c）;
　　printf（"%d＼n",c）;}
　　则程序的输出结果为
　　A）23
　　B）12
　　C）0
　　D）35
（41）若有以下语句，则正确的描述是
　　char a［］="toyou";
　　char b［］={′t′,′o′,′y′,′o′,′u′};
　　A）a数组和b数组的长度相同
　　B）a数组长度小于b数组长度
　　C）a数组长度大于b数组长度
　　D）a数组等价于b数组
（42）已知：char a［15］,b［15］={"I love china"};则在程序中能将字符串I love china赋给数组a的正确语句是
　　A）a="I love china";
　　B）strcpy（b,a）;
　　C）a=b;
　　D）strcpy（a,b）;
（44）阅读下面程序，则执行后的结果为
　　#include "stdio.h"
　　main（）
　　{  char *str="abcdefghijklmnopq";
　　 while（*str++!=′e′）;
　　 printf（"%c＼n",*str）;}
　　A）f
　　B）a
　　C）e
　　D）q
（45）现有如下程序段
　　#include "stdio.h"
　　int fun（int k,int *m）
　　{if（k%3）*m=k*k;
　　else *m=k/3;}
　　main（）
　　{ int （*p）（int,int *）,m;
　　 p=fun;
　　 （*p）（78,&m）;
　　 printf（"%d＼n",m）;}
　　则程序段的输出结果为
　　A）24
　　B）25
　　C）26
　　D）27
（46）阅读下列程序，则执行后的输出结果为
　　#include "stdio.h"
　　fun（int x）
　　{if（x/2>0）fun（x/2）;
　　printf（"%d",x%2）;}
　　main（）
　　{ fun（20）;
　　putchar（′＼n′）;}
　　A）11100
　　B）10100
　　C）10101
　　D）10110
（47）阅读如下程序段，则执行后程序的输出结果是
　　#include <stdio.h>
　　main（）
　　{structa{int x; int y;}num［2］={{20,5},{6,7}};
　　printf（"%d＼n",num［0］.x/num［0］.y*num［1］.y）;}
　　A）0
　　B）28
　　C）20
　　D）5
（48）阅读程序段，则执行后的输出结果为
　　#include "stdio.h"
　　typedef union{ long x［2］;
　　int y［4］;
　　char z［8］;} atx;
　　typedef struct aa{ long x［2］;
　　int y［4］;
　　char z［8］; } stx;
　　main（）
　　{printf（"union=%d,struct aa=%d＼n",sizeof（atx）,sizeof（stx））;}
　　A）union=8,struct aa=8
　　B）union=8,struct aa=24
　　C）union=24,struct aa=8
　　D）union=24,struct aa=24
（49）阅读下列程序段
　　#include "stdio.h"
　　typedef struct aa
　　{ int a;
　　 struct aa *next; } M;
　　void set（M *k,int i,int *b）
　　{ int j,d=0;
　　 for（j=1;j<i;j++）
　　{    k［j-1］.next=&k［j］;
　　k［j-1］.a=b［d++］; }
　　k［j］.a=b［d］; }
　　main（）
　　{ M k［5］,*p;
　　int d［5］={23,34,45,56,67};
　　set（k,5,d）;
　　p=k+1;
　　printf（"%d＼n",table）; }
　　则下面的表达式在table处，能使程序执行后，打印输出数据45的是
　　A）p->next->a
　　B）++p->a
　　C）（*p）.a++
　　D）p++->a
（50）阅读下面程序，程序实现的功能是（a123.txt在当前盘符下已经存在）
　　#include "stdio.h"
　　void main（）
　　{FILE *fp;
　　int a［10］,*p=a;
　　fp=fopen（"a123.txt","w"）;
　　while（ strlen（gets（p））>0 ）
　　{ fputs（a,fp）;
　　fputs（"＼n",fp）;}
　　fclose（fp）;}
　　A）从键盘输入若干行字符，按行号倒序写入文本文件a123.txt中
　　B）从键盘输入若干行字符，取前2行写入文本文件a123.txt中
　　C）从键盘输入若干行字符，第一行写入文本文件a123.txt中
　　D）从键盘输入若干行字符，依次写入文本文件a123.txt中

选择题

01-05　　B　　D　　B　　D　　B

06-10　　C　　A　　B　　C　　C

11-15　　C　　B　　D　　B　　B

16-20　　D　　B　　B　　D　　C

21-25　　D　　C　　B　　C　　A

26-30　　D　　D　　C　　D　　D

31-35　　D　　A　　C　　A　　D

36-40　　C　　A　　D　　C　　D

41-45　　C　　D　　A　　A　　C

46-50　　B　　B　　B　　A　　D

二、填空题

（1）排序是计算机程序设计中的一种重要操作，常见的排序方法有插入排序、 【1】 和选择排序等。
【命题目的】需要考生记住常见的排序方法。
【解题要点】常见的排序方法有插入排序（包括简单插入排序法和希尔排序法等）、交换排序（包括冒泡排序和快速排序法等）和选择排序（包括简单选择排序和堆排序等）。
    【考点链接】常见的排序方法及其作用机制和区别。

（2）当循环队列非空且队尾指针等于队头指针时，说明循环队列已满，不能进行入队运算。这种情况称为 【2】 。
【命题目的】本题考查了队列的基本性质。
【解题要点】入队运算是指在循环队列的队尾加入一个新元素。这个运算有两个基本操作：首先将队尾指针进一（即rear=rear+1），并当rear=m+1时置rear=1；然后将新元素插入队尾指针指向的位置。当循环队列非空（s=1）时且队尾指针等于队头指针时，说明循环队列已满，不能进行入队运算，这种情况称为“上溢”。

（3） 【3】 是一种信息隐蔽技术，目的在于将对象的使用者和对象的设计者分开。
【命题目的】本题考查了面向对象技术中的一些基本概念。 
【解题要点】面向对象技术中包括以下几个基本概念，即对象、类、方法、消息、继承和封装，其中封装是一种信息隐蔽技术，目的在于将对象的使用者对象的和设计者分开。

（4）为了便于对照检查，测试用例应由输入数据和预期的 【4】 两部分组成。
【命题目的】本题主要考查测试的步骤。
【考点链接】测试的基本方法和步骤。

（5） 【5】 是从二维表列的方向进行的运算。
【命题目的】本题考查了关系运算的基本知识。
【解题要点】在关系模型的数据语言中，一般除了运用常规的集合运算，（并、交、差、笛卡尔积等）外，还定义了一些专门的关系运算，如投影、选择、连接等。前者是将关系（即二维表）看成是元组的集合，这些运算主要是从二维表的行的方向来进行的；后者主要是从二维表的列的方向来进行的运算。两者统称为关系代数。

（6）定义int a=5,b=20;若执行语句printf（"%d＼n",++a*--b/5%13）;后，输出的结果为 【6】 。
解析： ++和--做前缀使用的时候，先对变量进行增1或减1，之后进行其他的运算,之后按照同级运算符自左向右依次运算。

（7）执行程序时的输入为123456789，则程序的运行结果为 【7】 。
#include "stdio.h"
main（）
{  int a,b;
 scanf（"%2d%*2d%1d",&a,&b）;
 printf（"%d＼n",a-b）;}
解析： 按照函数scanf中的格式控制符的描述："%2d"控制前2个数字赋给变量a，变量a的值为12，"%1d"控制将随后的1个数字作为输入数据存入变量b中，变量b的值为5，所以随后的输出为7。注意：在%和格式控制符号之间加*号，表示的是跳过相对应的输入数据。

（8）阅读下面程序，则在执行时候的输出为 【8】 。
 #include "stdio.h"
main（）
{int x=1,y=2,z=0;
if（x=2）z=x,x=y,y=z;
printf（"%d,%d＼n",x,y）;}
解析： if语句的执行过程为：首先计算紧跟在if后面一对圆括号中的表达式，如果表达式的值为非零，则执行其后的if子句，然后去执行if语句后的下一个语句，如果表达式为零，则跳过if子句直接执行if语句后的下一个语句，if（x=2）的值为真，即x的值为2。

（9）语句printf（"%d＼n",′H′-′0′+64）;的执行结果为 【9】 。
解析： 在C程序中的字符量可参与任何整数运算,在运算的时候都是以ASCII值进行的。

（10）阅读下面程序，则程序的执行结果为 【10】 。
#include "stdio.h"
main（）
{ int a=10;
 fun（a）;
 printf（"%d＼n",a）;}
fun（int x）
{ x=50;}
解析： 函数调用的时候，函数名字必须与所调用的函数名完全一致，形参与实参类型要一致，在没有给出函数返回值类型的情况下，默认为整形，当返回值为整型放到主函数后面时，可以不需要事先说明就调用这个函数。

（11）以下程序的输出结果是 【11】 。
int fun（int x,int y,int *p,int *q）
{ *p=x*y;
 *q=x/y;}
main（）
{int a,b,c,d;
a=4;b=3;
fun（a,b,&c,&d）;
printf（"%d,%d＼n",c,d）;}
解析： 通过地址传递可以在被调函数中对调用函数中的变量进行引用，通过地址的传递，在经过函数调用以后，改变了c,d变量的值。

（12）下面程序是求出数组arr的两条对角线上元素之和，请填空。
#include "stdio.h"
main（）
{int arr［3］［3］={2,3,4,8,3,2,7,9,8},a=0,b=0,i,j;
for（i=0;i<3;i++）
 for（j=0;j<3;j++）
if（ 【12】 ）a=a+arr［i］［j］;
for（i=0;i<3;i++）
for（ 【13】 ;j>=0;j--）
if（ 【14】 ）
b=b+ arr［i］［j］;
printf（"%d,%d＼n",a,b）;}
解析： 由于是求对角线元素的和，所以【12】是判断是否为对角线元素的，填i==j这个判断条件；对于次对角线的求和，初始化的时候应该是从数组的列最大开始，由于判断条件是j>=0，所以初始化时候应该为最大值减1，即j=2，所以【13】应填j=2；【14】是对次对角线的判断，所以填i+j==2。

（13）下面程序的功能是：对字符串从小到大进行排序并输出，请填空。
#include "string.h"
#include "stdio.h"
sort（char *a［］,int n）
{ int i,j;
char *p;
for（j=1;j<=n-1;j++）
for（i=0; 【15】 ;i++）
if（ 【16】 >0）
{ p=a［i］;
a［i］=a［i+1］;
a［i+1］=p;}}
main（）
{ int i;
char *book［］={"itisme","itisyou","howareyou","fine","goodnight","goodbye"};
sort（ 【17】 ）;
for（i=0;i<6;i++）
printf（"%s＼n",book［i］）;}
解析： 这个题目其实用的是冒泡排序法，每一次都找一个最大的，之后顺序的从头开始排列。所以【15】是一次循环的判定条件，填i

（14）下面的函数是完成1~n的累加，完成函数。
a（int k）
{if（k<=0）printf（"error＼n"）;
if（k==1） 【18】 ;
else 【19】 ;}
解析： 由于题目没有给循环语句，所以实现累加一定是用递归算法。

（15）阅读下列程序，则程序实现的功能是 【20】 。
#include "stdio.h"
struct node
{ char data;
 struct node *next; } *head;
fun（struct node *q）
{ if（head == NULL）
{q->next=NULL;
head=q;}
else
{ q->next=head;
head=q;}}
main（）
{char ch;
struct node *p;
head = NULL;
while（（ch=getchar（））!=′＼n′）
{p=（struct node *）malloc（sizeof（struct node））;
p->data=ch;
fun（p）; }
p=head;
while（p!=NULL）
{printf（"%c",p->data）;
p=p->next; }}
解析： 本题目的功能是从键盘输入一行字符，调用函数建立反序的链表，然后输出整个链表，从主函数开始依次向下对程序进行分析，分析初始化状态的程序，之后再分析函数的功能。