程序员应用技术 - 题库 - 天天查询

🏠 天天查询 > 题库 > 程序员应用技术

程序员应用技术

简答题

试题一
阅读下列程序或函数说明和 C 代码,将应填入__(n)__处的字句写在答题纸的对应栏内。
[函数1.1说明]
函数strcmp()是比较两个字符串 s 和 t 的大小。若 s < t 函数返回负数;若 s = t 函数返回0;若 s > t,函数返回正数。
[函数1.1]
int strcmp(char *s,char *t)
{ while ( *s && *t && __(1)__){
s++;t++ ;
}
return __(2)__;
}
[程序1.2说明]
在 n 行 n 列的矩阵中,每行都有最大的数,本程序求这 n 个最大数中的最小一个
[程序1.2]
#include〈stdio.h〉
#define N 100int a[N][N];
void main()
{ int row ,col ,max ,min ,n;
/*输入合法 n (〈100 ),和输入 m ×n 个整数到数组 a 的代码略*/
for ( row = 0;row < n;row++) {
for ( max = a[row][0],col = l ;col < n;col++)
if (__(3)__) max = a[row][col];
if (__(4)__) min = max;
else if(__(5)__) min = max;
}
printf ("The min of max numbers is %d\n",min);
}

简答题

试题二
阅读下列程序说明和C代码,将应填入__(n)__处的字句写在答题纸的对应栏内。
[程序2说明]
本程序中的函数 first_insert() 的功能是在已知链表的首表元之前插入一个指定值的表元;函数 reverse_copy() 的功能是按已知链表复制出一个新链表,但新链表的表元链接顺序与已知链表的表元链接顺序相反;函数 print_link() 用来输出链表中各表元的值;函数 free_link()用来释放链表全部表元空间。
[程序2〕
#include〈stdip.h〉
#include〈malloc.h〉
typedef struct node{ int val;
struct node *next;} NODE;
void first_insert( NODE **p,int v)
{ NODE *q = (NODE *) malloc( sizeof(NODE));
q -> va1 = v;__(1)__; *p = __(2)__;
}
NODE *reverse_copy(NODE *p)
{ NODE *u;
for( u = NULL ; p ; p = p ->next ) first_insert(__(3)__);
return u;
}
void print_link( NODE *p )
{ for( ;__(4)__) printf ("%d\t" , p -> val);
printf("\n");
void free_link(NODE*p)
{ NODE *u;
while( p != NULL){ u=p-〉next;free( p );__(5)__;}
}
void main()
{ NODE *link1 , *link2;
int i ;linkl = NULL ;
for( i = 1;i <= 10 ; i++ )
first insert( &link1,i );
link2 = revere_ copy(link1);
print_link(link1);freeJink(linkl);
print_link(link2);free_link(link2);
}

简答题

试题三
阅读下列程序说明和C代码,将应填入__(n)__处的字句写在答题纸的对应栏内。
[程序3说明]
本程序从若干个原始文件合并成的合并文件中恢复出其中一个或全部原始文件。所有文件均作为二进制文件进行处理。合并文件中先顺序存储各原始文件,然后顺序存储各原始文件的控制信息,即文件名、文件长度和在合并文件中的位置(偏移量)。其结构为:
typedef stmct{char fnme[256];/*原始文件名*/
long length;/*原始文件长度(字节数)*/
long offset;/*原始文件在合并文件中的位置(偏移量)*/
}FileInfo;
在合并文件最后存储如下一个特殊的标志信息作为合并文件的结束标记:
F11ek1fo EndF1ag={"Combined File".0,_offset};
其中_offset是第一个原始文件的控制信息在合并文件中的位置(偏移量)。
启动本程序的命令行的格式是:
程序名合并文件名[原始文件名]
如果不指定原始文件名,默认恢复合并文件中的所有原始文件。
程序中涉及的部分文件操作的库函数简要说明如下:
int fread(void *buffer,int size,int count,FILE *fbin):从二进制文件流 fbin 中读取count块长度为size字节的数据块到buffer指向的存储区。返回值为实际读取的数据块数。
int fwrite(void *buffer,int size,int count,FILE *fbin):各参数和返回值的意义与fread相同,但对文件进行写操作。
int fseek(FILE *fbin,long offset,int position): 将文件流 fbin 的读/写位置以 position为基准移动offset字节。position的值可以是SEEK_SET(文件头),SEEK_CUR(当前位置),SEEK_END(文件尾);offset为正表示向文件尾方向移动,为负表示向文件头方向移动,为零表示到基准位置。
long ftell(FILE *fbin): 返回文件流 fbin 的当前读/写位置(相对于文件头的偏移量)。上述偏移量均以字节为单位,即偏移字节数。
[程序3]
#include〈stdio.h〉
#include〈string.h〉
typedef struct{char fname[256];long length;long offset;}
}FileInfo;
void copyfile( FILE *fin, FILE *fout, int fsiz)
{ char buf[1024]; int siz = 1024 ;
while(fsiz != 0) { /*每次复制siz个字节,直至复制完fsiz个字节*/
if ( siz > fsiz) __(1)__ ;
fread( buf , 1 , siz , fin ) ; fwrite( buf , 1 , siz , fout );
fsiz = __(2)__;
}
}
int dofile( FILE *fin , FileInfo *inp )
{ long offset ;
FILE *fout ;
if ( ( fout = fopen( inp -〉fname , "wb" ) ) = NULL) {
printf ( "创建文件错误: %s\n" , inp -〉fname );
return 1 ;
}
offset = __(3)__ ; /*保留合并文件读/写位置*/
fseek( __(4)__) ; /*定位于被恢复文件首*/
copyfile( fin , fout , inp -〉length ) ;
fclose( fout ) ;
printf( "\n---文件名: %\n 文件长: %1d.\n " , inp -〉fname , inp -〉length );
__(5)__; /*恢复合并文件读/写位置*/
return 0 ;
}
　
int main( int argc ,char *argv[ ] )
{ FileInfo finfo ;
char fname[256] ; FILE *fcmbn;
if (argc < 2) { printf( "输入合并文件名:" ) ; scanf( "%s" , fname ) ; }
else strcpy( fname,argv[1]) ;
if ( ( fcmbn = fopen( fname , "rb" ) ) == NULL) {
printf( "文件打开错误:%s\n" , fname ) ; return 1;
}
fseek( fcmbn ,-sizeof(FileInfo),SEEK END);/*定位于合并文件末尾的标志信息*/
fread(&finfo,1,sizeof(FileInfo),fcmbn) ;
if ( finfo.length !=0 || strcmp( finfo.fmane , "CombinedFile" ) ) {
printf( "指定的文件不是合法的合并文件\n" ) ;
fclose( fcmbn ) ; return 2 ;
}
fseek(fcmbn,finfo.offset,SEEK_SET );/*定位于首个原始文件的控制信息*/
for ( ; ; ) { /*恢复一个(argc > 2) 或全部 ( argc = 2 )原始文件*/
fread( &finfo , 1 , sizeof( FileInfo ) , fCmbn ) ;
if ( finfo.length == 0 ) break ;
if ( argc > 2 && strcmp( finfo.fname , argv[2] ) ) continue ;
if ( dofile( fcmbn , &finfo ) != 0 ) break ;
}
fclose( fcmbn ) ; return 0 ;
}

简答题

试题四
阅读下列程序说明和C代码,将应填入__(n)__处的字句写在答题纸的对应栏内。
[程序4说明]
设一个环上有编号为 0～n-1 的 n 粒不同颜色的珠子(每粒珠子颜色用字母表示, n 粒珠子颜色由输入的字符串表示)。以环上某两粒珠子间为断点,从断点一方按顺时针方向取走连续同色的珠子,又从断点另一方按逆时针方向对剩下珠子取走连续同色的珠子,两者之和为该断点可取走珠子的粒数。移动断点,能取走的珠子数不尽相同。本程序找出可以取走最多的珠子数及断点的位置。程序中用双向链表存储字符串。例如,编号为0-9的10粒珠子颜色的字符串为“aaabbbadcc",对应链表为:

若在2号与3号珠子间为断点,共可取走6粒珠子,且为取走的珠子数最多。
[程序4]
#include〈stdio.h〉
#include〈string.h〉
#include〈malloc.h〉
typedef struct node { char d ;
struct node *fpt ; /*后继指针*/
struct node*bpt ; /*前趋指针*/
}NODE ;
NODE *building( char *s ) /*生成双向循环链表*/
{ NODE *p = NULL , *q ;
while ( *s ){
q = ( NODE * ) malloc( sizeof( NODE ) ) ;
q -> ch = *s++ ;
if ( p = NULL ) p = q -> fpt = q -> b t = q ;
else {
p -> bpt -> fpt = q ;
q -> fpt = p ;
q -〉bpt = __(1)__;
__(2)__ ;
}
}
return
}
int count( NODE *start , int maxn ,int step ) /*求可取走珠子粒数*/
{ int color ,c ;
NODE *p ;
color = -1 ; C = 0 ;
for ( p = start ; c <maxn ; p = step > O ? p -> fpt ; p -> bpt ){
if ( color == -1 ) color = p -> ch ;
else if (__(3)__) break ;
c++
}
return
}
　
int find ( char *s ,int *cutpos ) /*寻找取走珠子数最多的断点和粒数*/
{ int i , c , cut , maxc = 0 ,1en = strlen(s) ;
NODE *p ;
if ( ( p = building(s) ) = NULL ){ *cu1tpos = -1 ; return -1 ; }
i = 0 ;
do { c = count( p , 1en ,1 ) ;
c = c + __(4)__ ;
if ( c > maxc ) { maxc = c ; cut = i ; }
__(5)__ ;
i++ ;
} while (i < len ) ;
* cutpos = cut ;
return maxc ;
}
　
void main()
{ int cut , max ;
char s[120] ;
scanf( , %s', s ) ;
max = find( s , &cut ) ;
printf ( "Cut position = %d , Number = %d.\n" , cut , max ) ;
}

简答题

试题五
阅读下列程序说明和C代码,将应填入__(n)__处的字句写在答题纸的对应栏内。
[程序5说明]
本程序采用递归算法将一个自然数 n 分解成不多于 m 个整数之和。设构成和数 n 的各个整数取于数组 d ,d 中的整数互不相等且由大到小存储。
例如,数组 d 中存储以下整数: d[] = {100 ,81 ,64 ,49 ,36 ,25 ,16 ,9 ,4 ,1} ,则有:

n	m	程序运行后的输出
100	2	100 = 100
13	2	13 = 9 + 4
14	2	No answer (9+4+1超过2个)
71	5	71 = 49 + 9 + 9 + 4 (表示可重复取数)

　
函数 End()的形参 c 表示 d 中可取的整数个数;形参 pd 指向能成为和数的整数的存放位置。
[程序5]
#include〈stdio.h〉
#define N 20
int find( int n ,int m ,int *d ,int c ,int *pd )
{ int r ;
if ( n == 0 ) return 0 ; /* 已分解完成 */
if ( m == 0 || c == 0 ) return -1 ; /* 不可以分解 */
if ( __(1)__ ) return find( n ,m , d+1 ,c-1 ,pd ) ;
else { *pd = *d ;
r = find( __(2)__ ,d , c , __(3)__ ) ; /* 继续对剩余数作分解 */
if ( r >= 0 ) return __(4)__ ;
return find( n ,m , __(5)__ ,pd ) ;
}
}
void main()
{ int n ,m ,k ,i ,p[N] ,*pptr = p ;
int d[ ] = { 100, 81, 64, 49, 36, 25, 16, 9, 4, 1 } ;
printf( "Enter n , m : " ; scanf( %d %d ,&n ,&m );
k = find( n , m , d , 10 , pptr ) ;
if ( k <= O ) printf ( "No answer!\n" ) ;
else{ printf( "%d = %d" , n , p[0] ) ;
for ( i = l ; i < k ; i++ )
printf(" +%d" , p[i] ) ;
printf("\n");
}

简答题

试题一
阅读下列算法说明和算法，将应填入 (n) 处的字句写在答题纸的对应栏内。
[算法说明]
为便于描述屏幕上每个像素的位置，在屏幕上建立平面直角坐标系。屏幕左上角的像素设为原点，水平向右方向设为x轴，垂直向下方向设为y轴。
设某种显示器的像素有128X128，即在每条水平线和每条垂直线上都有128个像素。这样，屏幕上的每个像素可用坐标(x，y)来描述其位置，其中x和y都是整数，0≤x≤127，0≤y≤127。
现用一维数组MAP来存储整个一屏显示的位图信息。数组的每个元素有16位二进位，其中每位对应一个像素，“1”表示该像素“亮”，“0”表示该像素“暗”。数组MAP的各个元素与屏幕上的像素相对应后，其位置可排列如下：
MAP(0)，MAP(1)，……，MAP(7)
MAP(8)，MAP(9)，……，MAP(15)
……
MAP(1016)，MAP(1017)，……，MAP(1023)
下述算法可根据用户要求，将指定坐标(x，y)上的像素置为“亮”或“暗”。
在该算法中，变量X，Y，V，S，K都是16位无符号的二进制整数。数组BIT中的每个元素BIT(K)(K=0，…，15)的值是左起第K位为1，其余位均为0的16位无符号二进制整数，即BIT(K)的值为2l5-k。
[算法]
第1步根据用户指定像素的位置坐标(x，y)，算出该像素的位置所属的数组元素MAP(V)。这
一步的具体实现过程如下：
1、将x送变量X，将y送变量Y；
2、将Y左移 (1) 位，仍存入变量Y；
3、将X右移 (2) 位，并存入变量S；
4、计算Y+S，存入变量V，得到像素的位置所属的数组元素MAP(V)。
第2步算出指定像素在MAP(V)中所对应的位置K(K=0，…，15)。这一步的具体实现过程如下：
将变量X与二进制数 (3) 进行逻辑乘运算，并存入变量K。
第3步根据用户要求将数组元素MAP(V)左起第K位设置为”1”或”0”。这一步的具体实现过程
如下：，
1、为在指定像素置“亮”，应将MAP(V)与BIT(K)进行逻辑 (4) 运算，并存入MAP(V)。
2、为在指定像素置“暗”，应先将BIT(K)各位取反，再将MAP(V)与BIT(K)进行逻辑 (5) 运算，并存入MAP(V)。

简答题

试题二
阅读下列函数说明和C代码，将应填入—匹l处的字句写在答题纸的对应栏内。
[函数2．1说明]
函数strcat(char *si，char *s2)是将字符串s2连接在字符串si之后，构成一个首指
针为s1的字符串。
[函数2.1]
void strcat(char *sl，char *s2)
{ while(*s1!='\0') ；
(1) ：
for( ； (2) ；s1++，s2++)；
}
[函数2．2说明] ．
本函数输入n(<1000)个整数到指定数组，求该数组中最大元素的值和此元素的下标，最大元素值以函数值返回，此元素的下标通过指针形参带回调用处。
[函数2．2]
#include<stdio．h>
#define MAXLINE 1000
int maxindex(int a[]，int *index)
{ int i，n；
do {
printf("Please input n＼n")；
scanf("％d"，&n)；
}while( (3) )；/*保证输入的n在限定范围内*/
for(i=0 ; i<n ; i++)
scanf("%d"，&a[i])；
*index=0；
for(i=1 ; i<n ; i++)
if( (4) ) *index=i；
return (5) ；
}

简答题

试题三
阅读下列函数说明和C代码，将应填入(n)处的字句写在答题纸的对应栏内。
[函数3．1说明]
函数insert_sort(int a[]，int count)是用直接插入排序法对指定数组的前count个元素从小到大排序。
直接插入排序法的基本思想是：将整个数组(count个元素)看成是由有序的(a[0]，…，a[i-1])和无序的(a[i]，…，a[Count-1))两个部分组成；初始时i等于1，每趟排序时将无序部分中的第一个元素a[i]插入到有序部分中的恰当位置，共需进行count-1趟，最终使整个数组有序。
[函数3.1]
void insert_sort(int a[] , int count)
{ int i, j, t;
for(i=1 ; i<count ; i++)
{ /*控制a[i],……, a[count-1]的比较和插入*/
t=a[i];
j= (1) ;
while (j>=0 && t<a[j])
{ /*在有序部分中寻找元素a[i]的插入位置*/
(2) ;
j--;
}
(3) ;
}
}
[函数3．2说明]
递归函数invert(int a[]，int k)将指定数组中的前k个元素逆置。
[函数3．2]
void invert(int a[] , int k);
{ int t;
if ( (4) ) {
invert( (5) );
t=a[0];
a[0]=a[k-1];
a[k-1]=t;
}
}

简答题

试题四
阅读下列程序说明和C代码，将应填入 (n) 处的字句写在答题纸的对应栏内。
[程序4说明]
本程序用古典的Eratosthenes的筛法求从2起到指定范围内的素数。如果要找出2至10中的素数，开始时筛中有2到10的数，然后取走筛中的最小的数2，宣布它是素数，并把该素数的倍数都取走。这样，第一步以后，筛子中还留下奇数3、5、7、9：重复上述步骤，再取走最小数3，宣布它为素数，并取走3的倍数，于是留下5、7。反复重复上述步骤，直至筛中为空时，工作结束，求得2至10中的全部素数。
程序中用数组sieve表示筛子，数组元素sieve[i]的值为1时，表示数i在筛子中，值为-1时表示数i已被取走。
[程序4]
#include <stdio.h>
#define MAX 22500
main()
{ unsigned int i , range , factor , k ;
int sieve[MAX] ;
printf(“please input the range : ”);
scanf(“%d”,&range); /*range指出在多大的范围内寻找素数 */
for (i=2 ; i<=range ; i++) /* 筛子初始化 */
(1) ;
factor=2 ;
while (factor<=range) {
if ( (2) ) { /*筛子最小数是素数 */
printf(“%d\t”,factor);
k=factor;
while (k<=range)
{ /*移走素数的倍数 */
(3) ; /*筛中的个数减一 */
k= (4) ;
}
}
(5) ;
}

简答题

试题五
阅读下列函数说明和C代码，将应填入 (n) 处的字句写在答题纸的对应栏内。
设二叉树的结点数据类型为：
typedef struct node{
char data；
struct node *left；
struct node *right：
}BTREE；
[函数5.1说明]
函数void SortTreelnsert(BTREE **tree，BTREE*s)采用递归方法，将结点s插入以*tree为根结点指针的二叉排序树(二叉查找树)中。
[函数5.1)
void SortTreelnsert(BTREE **tree，BTREE *S)
{ if(*tree = = NULL) *tree=S;
else if(S->data<(*tree)->data)
SortTreelnsert( (1) ，S)；
else if(S->data>(*tree)->data)
SortTreelnsert( (2) ，S)；
}
[函数5．2说明]
函数void TraversalTree(BTREE *tree)用非递归方法，对以tree为根结点指针的二叉树进行后序遍历。
[函数5，2]
void TraversalTree(BTREE *tree)
{ BTREE *stack[1000]，*p；
int tag[1000]，top=0；
p=tree；
do {
while(p!=NULL){
stack[++top]=p；
(3) ；
tag[hop]=0；／*标志栈顶结点的左子树已进行过后序遍历*／：
}
while(top>0 && (4) ){ /* 栈顶结点的右子树是否被后序遍历过*／
p=stack[top--];
putchar(p->data)；
}
if (top>0) { /*对栈顶结点的右子树进行后序遍历*／
(5) ；
tag[top]=1；
}
}while(top>0)；
}

简答题

试题一
阅读下列算法说明和算法，将应填入__(n)__处的字句写在答卷的对应栏内。
[算法说明]
　　某英汉词典文件包含N个记录(N>1)，每个记录有两个字段：一个是英文单词，另一个是相应的汉语解释。各个记录按英文单词的词典顺序排列，各英文单词并不重复。
　　本算法用于维护、更新该英汉词典文件。维护、更新的方法是：首先输入一个英文单词及其汉语解释，然后在该词典中查找输入的英文单词，若找到，则用输入的汉语解释更新原有的解释；若找不到，则需要将输入的英文单词及其汉语解释插入到该词典的适当位置，使各记录仍按英文单词的词典顺序排列。
[算法]
　　第一步读入英汉词典文件，并将读入的N个英文单词依次存放在字符串数组ENG中，将相应的汉语解释依次存放在字符串数组CN中。数组元素CN(i)给出了数组元素ENG(i)的解释。
　　第二步输入英文单词及其汉语解释，将它们分别存放在字符串变量E和C中。若E为空串或都是空格，则转向第四步。
　　第三步根据变量E的值，用二分法在数组ENG中查找。具体步骤如下：
　　　(1)1 -->L，N -->H
　　　(2)INT((L+H)／2) -->K
　　　(3)若E = ENG(K)，则C --> CN(K)，转向第二步
　　　　若E < ENG(K)，则K-1 -->__(1)__；若E > ENG(K)，则K+1 -->__(2)__
　　　(4)若H<L，则对I = N，L，-1(始值，终值，增量)循环执行：
　　　　　ENG(I) --> ENG(I+1)
　　　　　CN(I) -->CN(I+1)
　　　　然后，将E和C分别存入__(3)__和__(4)__，N+1 --> N 最后转向第二步
　　　　否则，转向___(5)___
　　第四步将数组ENG和CN输出，形成新的英汉词典文件，算法结束.

简答题

试题二
阅读下列函数说明和C代码，将应填入__(n)___处的字句写在答题纸的对应栏内。
[函数2.1说明]
　　函数char *strrchr(char*s，char ch)的功能是在字符串s中寻找字符ch若ch出现在字符串s中，则返回最后一次出现时的位置，否则返回NULL。

[函数2.1]
char *strrchr(char *s，char ch)
{
　char*p；
　p = __(1)__; `/*p指向字符串s的结束标志*/
　while( --p >= s)
　　if(__(2)__) return p;
　return NULL;
}

[函数2.2说明]
　　函数BTREE *SortTreeSearch(BTREE *tree，int d)采用非递归方法，在二叉排序树(二叉查找树)中查找键值为d的结点。若找到，则返回键值所在结点的指针，否则返回NULL。
　　二叉查找树的结点类型为：
typedef struct node{
　int data；／*结点的键值*／
　struct node *left；
　struct node *right；
}BTREE；

[函数2.2]
BTREE *SortTreeSearch(BTREE *tree，int d)
{
　BTREE *ptr = tree;
　while(ptr != NULL && d != ptr->data){
　　if(d < ptr->data)
　　　__(3)__;
　　else
　　　__(4)__;
　}
　return__(5)___;
}

简答题

试题三
阅读下列函数说明和C代码，将应填入__(n)__处的字句写在答题纸的对应栏内。
[函数3说明]
　　函数ELEM *proc(FILE *fp)从文件fp中逐个读入职工的工号及其完成的产品数量，对相同工号的产品数量计入该职工完成的产品总数，并且按照产品总数降序排列，若多个职工完成的产品总数相同，则按工号升序排列。函数中建立了一个有序链表，来存储每个职工的工号和完成产品总数等数据，其结点类型为：
typedef struct ELE{
　int no； /*职工工号*／
　int num； /*完成的产品总数*／
　struct ELE *next；
}ELEM;

[函数3]
ELEM *proc(FILE *fp)
{
　int m，n；
　ELEM *u,*v,*p,*base;
　base = NULL; /*base是链表的首指针*／
　while(fscanf(fp，"%d%d",&n，&m) == 2){
　　／*链表中是否存在工号为n的结点*／
　　for(v = base；v != NULL && v->no != n; __(1)___);
　　if(v != NULL) {／*若链表中已有工号为n的结点v，则将其从链表中脱钩*／
　　　if(__(2)__ base = v->next;
　　　else u->next = v->next;
　　　v->num += m; /*累加工号为n的职工完成的产品数量*／
　　}
　　else { ／*创建一个工号为n的结点*／
　　　v = (ELEM *)malloc(sizeof(ELEM));
　　　v->no = n； v->num = m；
　　}
　　/* 寻找结点v的插入位置*／
　　p = base;
　　while(p != NULL)
　　　if(v->num > p->num || v->num == p->num && ___(3)___) break;
　　　else {u = p; p = p->next; }
　　/* 将结点v插入链表*／
　　if(p == base) __(4)__;
　　else u->next = v;
　　__(5)__;
　}
　return base;
}

简答题

试题四
阅读下列函数说明和C代码，将应填入__(n)__处的字句写在答题纸的对应栏内。
[函数4说明]
函数void rcr(int a[]，int n,int k)的功能是：将数组a中的元素a[0]～a[n-1]循环向右平移k个位置。
为了达到总移动次数不超过n的要求，每个元素都必须只经过一次移动到达目标位置。在函数rcr中用如下算法实现：首先备份a[0]的值，然后计算应移动到a[0]的元素的下标p，并将a[p]的值移至a[0]；接着计算应移动到a[p]的元素的下标q，并将a[q]的值移至a[p];依次类推，直到将a[0]的备份值移到正确位置。
若此时移动到位的元素个数已经为n，则结束；否则，再备份a[1]的值，然后计算应移动到a[1]的元素的下标p，并将a[p]的值移至a[1]；接着计算应移动到a[p]的元素的下标q，并将a[q]的值移至a[p];依次类推，直到将a[1]的备份值移到正确位置。
若此时移动到位的元素个数已经为n，则结束；否则，从a[2]开始，重复上述过程，直至将所有的元素都移动到目标位置时为止。
例如，数组a中的6个元素如下图(a)所示，循环向右平移2个位置后元素的排列情况如图(b)所示。

41	25	38	47	65	76		65	76	41	25	38	47
a[0]	a[1]	a[2]	a[3]	a[4]	a[5]		a[0]	a[1]	a[2]	a[3]	a[4]	a[5]

(a) (b)
[函数4]
void rcr(int a[]，int n，int k)
{
　int i，j，t，temp，count;
　count = 0；／*记录移动元素的次数*／
　k = k ％ n;
　if(__(1)__){ /*若k是n的倍数，则元素无须移动；否则，每个元素都要移动*／
　　i = 0;
　　while(count < n) {
　　　j = i; t = i;
　　　temp = a[i]; ／*备份a[i]的值*／
　　　/* 移动相关元素，直到计算出a[i]应移动到的目标位置*／
　　　while((j = __(2)__) != i){
　　　　a[t] = a[j];
　　　　t = __(3)___;
　　　　count++;
　　　}
　　　__(4)___ = temp; count++;
　　　__(5)___;
　　}
　}
}

简答题

试题五
阅读下列说明和C代码，将应填／k_(n)—处的字句写在答题纸的对应栏内。
[说明]
　　本题给出四个函数，它们的功能分别是：
　　①int push(PNODE *top，int e)是进栈函数，形参top是栈顶指针的指针，形参e是入栈元素。
　　②int pop(PNODE *top，int oe)是出栈函数，形参top是栈顶指针的指针，形参e作为返回出栈元素使用。
　　③int enQueue(PNODE *tail，int e)是入队函数，形参tail是队尾指针的指针，形参e是入队元素。
　　④int deQueue(PNODE *tail，int *e)是出队函数，形参tail是队尾指针的指针，形参e作为返回出队元素使用。
以上四个函数中，返回值为0表示操作成功，返回值为-1表示操作失败。栈是用链表实现的；队是用带有辅助结点(头结点)的单向循环链表实现的。两种链表的结点类型均为：
typedef struct node{
　int value;
　struct node *next;
}NODE，*PNODE;

[函数①]
int push(PNODE *top，int e)
{
　PNODE p = (PNODE)malloc(sizeof(NODE));
　if(!p) return –1;
　p->value = e;
　___(1)___;
　*top = p;
　return 0;
}

[函数②]
int pop(PNODE *top，int *e)
{
　PNODE p = *top;
　if(p == NULL) return –1;
　*e = p->value;
　___(2)____;
　free(p);
　return 0;
}

[函数③]
int enQueue(PNODE *tail，int e)
{
　PNODE p，t；
　t = *tail;
　p = (PNODE)malloc(sizeof(NODE))；
　if(!p) return –l;
　p—>value = e;
　p—>next = t—>next;
　____(3)____;
　*tail = p;
　return 0;
}

[函数④]
int deQueue(PNODE *tail，int *e)
{
　PNODE p，q；
　if((*tail)->next == *tail)return –1;
　p = (*tail)->next;
　q = p->next;
　*e = q->value;
　___(4)___ = q->next;
　if(*tail = q) ___(5)___;
　free(q);
　return 0;
}

简答题

试题一
　　阅读下列说明、流程图和算法，将应填入__(n)__处的字句写在答题纸的对应栏内．
[流程图说明]
　　下面的流程图用N—S盒图形式描述了数组A中的元素被划分的过程．其划分方法是：
　　以数组中的第一个元素作为基准数，将小于基准数的元素向低下标端移动，而大于基准数的元素向高下标端移动．当划分结束时，基准数定位于A[i]，并且数组中下标小于i的元素的值均小于基准数，下标大子i的元素的值均大于基准数。设数组A的下界为low，上界为high，数组中的元素互不相同。例如，对数组(4，2，8，3，6)，以4为基准数的划分过程如下：
[流程图]

　　
[算法说明]
　　将上述划分的思想进一步用于被划分出的数组的两部分，就可以对整个数组实现递增排序。设函数int p(int A[]，int low，int high)实现了上述流程图的划分过程并返回基准数在数组A中的下标。递归函数void sort(int A[]，iht L，int H)的功能是实现数组A中元素的递增排序。
[算法]
　void sort(int A[]，iht l，int H)　{
　if ( L < H ) {
　　k=p(A，L，R)；　　　　　//p()返回基准数在数组A中的下标
　　sort(__ (4)__；　　　　 //小于基准数的元素排序
　　sortl__ (5)__)；　　　　//大于基准数的元素排序
　　}
　}

简答题

试题二
　　阅读下列函数说明和C函数，将应填入__(n)__处的字句写在答题纸的对应栏内。
[函数2.1说明]
　　函数palindrome(chars[])的功能是：判断字符串s是否为回文字符串，若是，则返回0，否则返回-1。若一个字符串顺读和倒读都一样时，称该字符串是回文字符串，例如：“LEVEL”是回文字符串，而“LEVAL”不是。
[函数2.1]
　int palindrome(char S[])
　{ char　*pi，*pj；
　　pi＝S；pj＝s+strlen(S)-1：
　　while ( pi<pj && __(1)__){
　　　pi++； pj--；
　　}
　　if(__ (2)__)return-1；
　　else return 0；
　}
[函数2.2说明]
　　函数f(char *str，char del)的功能是；将非空字符串str分割成若干个子字符串并输出，del表示分割时的标志字符。
　　例如若str的值为“33123333435”，del的值为‘3’，调用此函数后，将输出三个子字符串，分别为“12”、“4”和“5”。
[函数2.2]
　void f(char*str，char del)
　{ int i，j，len；
　　len = strlen(str)；
　　i = 0；
　　while　(i<len){
　　　while　(__(3)__)　i++；　　　　/*忽略连续的标志字符*/
　　/*寻找从str[i]开始直到标志字符出现的一个子字符串*/
　　　j = i + 1；
　　while (str[j] !=del && str[j] !='\0') j++；
　　__ (4)__＝"\0"；　　　　　　　　 /*给找到的字符序列置字符串结束标志*/
　　printf(" %s\t"，&str[i])： ’
　　__ (5)__；
　　}
　}

简答题

试题三
　　以下是与Visual Basic开发应用有关的5个问题．对每一个问题，请将解答填入答题纸的对应栏内。
　　(1)在Visual Basic中，工程文件、窗体文件和标准模块文件的扩展名是什么?
　　请从下列选项中选择：
　　prg、prj、exe、vbp、rom、frm、win、fra，std、bas、vbs、Vbm
　　(2)设某窗体上有一个命令按钮，其名称为 CmdSave，运行时该按钮上显示有“保存(S)”字样的信息。为使热键 ALT+S 与该命令按钮相关联，应该对按钮 CmdSave 的 Caption属性设置什么样的属性值?
　　(3)设某窗口内有一个图像框 Image1，以及两个命令按钮“放大”和“缩小”。单击“放大”按钮就会使该图像框的长和宽都放大10%；单击“缩小”按钮就会使该图像框的长和宽都缩小10%（该图像框的左上角不动）。请分别写出这两个命令按钮的单击事件过程中的程序代码。
　　(4)为使某个单选按钮初始时默认被选中，在开发时应怎样做?
(5)若有语句 Tmpval=MsgBox（非法操作!，ybOKCancel+vbCritical，"提示"），请简要描述程序运行时弹出的消息框的主要特征。

简答题

试题四
　　阅读以下说明和C代码，将应填入__(n)__处的字句写在答题纸的对应栏内。
[说明]
　　函数 MultibaseOutput(long n，int B)的功能是：将一个无符号十进制整数 n 转换成 B（2≤B≤16）进制数并输出。该函数先将转换过程中得到的各位数字入栈，转换结束后再把 B 进制数从栈中输出。有关栈操作的诸函数功能见相应函数中的注释。C代码中的符号常量及栈的类型定义如下：
　#define KAXSIZE 32
　typedef struct{
　　int *elem；　　/* 栈的存储区 */
　　int max；　　　/* 栈的容量，即找中最多能存放的元素个数 */
　　int top；　　　/* 栈顶指针 */
　}Stack；
[C代码]
　int lnitStack(Stack *S，int n)　　/* 创建容量为n的空栈 */
　{ S->elem = (int *)matloc(n * sizeof(int))；
　　if (S->elem == NULL) return -1；
　　S->max = n；__(1)__= 0；return 0；
　}
　int Push(Stack*S，int item)　　　/* 将整数item压入栈顶 */
　{ if(S->top == S->max){ printf("Stack is full!\n")；return -1；}
　　__(2)__；item；return 0；
　}
　int StackEmpty(Stack S){ return(!S.top) ? 1；0；)　/* 判断栈是否为空 */
　int Pop(Stack*S)　　　　　　　　/* 栈顶元素出栈 */
　{ if (!S->top){ printf("Pop an empty stack!\n")；return -1；)
　　return __(3)__；
　}
　void MultibaseOutput(long n，int B)
　{ int m；Stack S；
　　if (init Stack(&S，MAXSIZE)) { printf("Failure!\n")；return；}
　　do {
　　　if (Push(&s，__(4)__)) { printf("Failure!\n")；return；}
　　　n = __(5)__：
　　} while (n != 0)；
　　while (!StackEmpty(S))　{　　　　　/* 输出B进制的数 */
　　　m = Pop(&S)；
　　　if (m < 10) printf("Kd"，m)；　　/* 小于10，输出数字 */
　　　else printf("%c，m + 55)；　　　 /* 大于或等于10，输出相应的字符 */
　　}
　　printf("\n")；
　}

简答题

试题五
　　阅读以下应用说明及Visual Basic程序代码，将应填入__(n)__处的字句写在答题纸的对应栏内。
[应用说明5.1]
　　本应用程序的窗体中有一个下拉式列表框（名称为Combol）和两个文本框（名称分别为Txtl和Txt2）。运行时，用户从Combol的列表中进行选择，程序就会将选中条目的内容以及编号（从0开始）分别在文本框 Txt1 和 Txt2 中显示出来。
[程序代码5.1]
　Private Sub Combol_C1ick()
　　Txtl.Text = Combol.__(1)__
　　Txt2.Text = Combol.__(2)__
　End Sub
　　（注：可供(2)处选择的选项：List，Index，Listlndex，ListCount，Number）
[应用说明5.2]
　　本应用程序的运行窗口如下图所示：

当用户在输入框（名为Txtln）中输入数值数据，并从下拉式列表框（名为CmbOp）中选择所需的运算后，输出框（名为TxtOut）中就会显示运算的结果。用户单击“清除”按钮（名为CmdClear）后，输入框和输出框都清空。
开发该应用的部分程序代码如下：
[程序代码5.2]
　Private Sub CmbOp_Click()
　　Dim DataIn As Double，DataOut as Double
　　DataIn = __(3)__
　　Select Case __(4)__
　　　Case "取整数部分"
　　　　DataOut = Int(Dataln)
　　　Case "求平方根"
　　　　If Dataln < O Then
　　　　　MsgBox$("负数不能开平方!")
　　　　Else
　　　　　DataOut = Sqr(Dataln)
　　　　End If
　　　Case "取绝对值"
　　　　DataOut = Abs(Dataln)
　　　　(TxtOut.Text = str$(DataOut)
　　　　__5)__
　End Sub

简答题

试题六
　　阅读下列函数说明和 C 函数，将应填入__(n)__处的字句写在答题纸的对应栏内。
[函数6说明]
　　函数DelAInsB(LinkedList La，LinkedList lb，int key1，int key2，int len)的功能是，将线性表A中关键码为keyl的结点开始的len个结点，按原顺序移至线性表B中关键码为key2的结点之前，若移动成功，则返回0；否则返回-1。线性表的存储结构为带头结点的单链表，La为表A的头指针，Lb为表B的头指针。单链表结点的类型定义为：
　typedef struct node{
　　int key；
　　struct node*next；
　}*Linkedhist；
[函数6]
　int DelllnsB(LinkedLiSt La，LinkedList Lb，int keyl，int key2，int len)
　{ LinkedList p，q，S，prep，pres；
　　int k；
　　if (!La->next || !Lb->next || len<=0)　return-1；
　　p = La->next； prep = La；
　　while (p && p->key != keyl){　　　/* 查找表A中键值为key1的结点 */
　　　prep = p； p = p->next；
　　}
　　if (!p) return -1；　　　　　　　　/* 表A中不存在键值为key1的结点 */
　　q = p； k = 1；
　　while (q && __(1)__){　　　　　　　/* 在表A中找出待删除的len个结点 */
　　　__(2)__： k++；
　　}
　　if (!q) return -1；　　　　　　　　/* 表A中不存在要被删除的len个结点 */ •
　　S = Lb->next；__ (3)__；
　　while (s && s->key != key2){　　　/* 查找表B中键值为key2的结点 */
　　pres = s； s = s->next；
　　}
　　if (!s)return -1；　　　　　　　　/* 表B中不存在键值为key2的结点 */
　　__(4)__q->next；　　　　　　　　　/* 将表A中的len个结点删除 */
　　q->next：__(5)__
　　pres->next = p；　　　　　　　　　/* 将len个结点移至表B */
　　return 0；
　}

简答题

试题七
　　阅读以下应用说明、属性设置及VisualBasic程序代码，将应填入__(n)__处的字句写在答题纸的对应栏内。
[应用说明7]
　　本应用程序的运行窗口如下图所示：

只要用户单击“闪烁”按钮，文字“欢迎光临”就会以0.3秒消失、0.3秒显示反复进行闪烁；单击“停止”按钮时，闪烁停止，恢复图示的初态。
　　在开发过程中，需要设置的属性如下：
[属性设置7]

在开发过程中，需要编写的程序代码如下；
[程序代码7]
　Private Sub CmdF Click()
　　Timerl.__(3)__ = True
　　Label.Visible = False
　End Sub
　Private Sub Timerl_ Timer()
　　__(4)__ = not Label.Visible
　End Sub
　Private Sub CmdT Click()
　　Timerl.Enabled = __(5)__
　　Label.Visible = true
　End Sub

简答题

试题八
　　阅读下列程序说明和C程序，将应填入__(n)__处的字句写在答题纸的对应栏内。
[程序8说明]
　　程序8用于计算某公司每个职工应缴纳的个人所得税额和全体职工缴纳的个人所得税总额。职工的当月收入（工资或薪金）通过键盘输入，每次输入一个职工的工号和工资（或薪金）。由于该公司的工资或薪金是不定时发放的，所以输入过程中每个职工的收入会出现多次输入，整个输入以工号小于等于0结束。
　　假设个人所得税法规定；个人收入所得，按月计税，以每月收入总额减除免税金额800元后的余额作为该月的月应纳税所得额，适用税率如下表所示。

上表表明，个人收入所得税是按照超额累进的税率来征收的。
　　设一个人的月应纳税所得额为K(元)，用下面的公式计算其应缴纳的个人所得税额S(元):
　　若0<K≤500，则S=K×5％；
　　若500<K≤2000，则S=500×5％+(K—500)×10％：
　　若2000<K≤5000，则S=500×5％+1500×10％+(K-2000)×15％：
　　若5000<K≤20000，则S=500×5％+1500×10％+3000×15％+(K-5000)×20％：
　　例如，某人某月工资总额为4100元，减去800元后，应纳税所得额为3300元，其应缴纳的个人所得税额为500*5％+1500*10％+1300*15％=370元。
[程序8]
　#include　<stdio.h>
　#define MaxNum 50
　#define BASE 800　　　　　/*免税金额基数*/
　int paylevel[]={0，500，2000，5000，20000，40000，60000，80000，100000，100000¨：
　int taxPrate[]={5，10，15，20，25，30，35，40，45)： /*税率表*/
　typedef struct{
　　int ld；　　　　/*职工的工号*/ ．
　　long Salary；　　/*职工的工资*/
　}Info；
　/* 查找工号为Id的职工在数组employee中的下标，返回值为0表示没有 */
　int find(int ld，Info employee[]，int m){
　　int j；
　　employee[0]._dj=Id；
　　for(j＝m；__(1)__；j--)；
　　　return j；
　}
　void main(void)
　{ Info employeeCHaxNum+1]；
　　long Wage；
　　double sum s 0，K，S：
　　int i，j，N＝0，Code；
　　scanf("M％ld"，&Code，&Wage)；　　 /*读入职工号、工资或薪金*/
　　while(Code>0)　{
　　　i＝find(Code，employee，N)；
　　　if (i>0)employee[i].Salary += Wage：
　　　else{　__ (2)__；
　　　employee[N].Id＝Code；employee[N].Salary＝Wage；
　　　}
　　　scanf("％d％ld"，&Code，&Wage)：
　　}
　　for　(i＝1；i<＝N；i++){
　　　K = __(3)__；　　　　　　　　　/*计算月应纳税所得额*/
　　　S＝0；　　　　　　　　　　　　 /*月应纳税额赋初值*/
　　　if (K > 0) {
　　　　for (j＝1；j<＝9；j++)
　　　　　if(__(4)__)　　　　　　　　/*月应纳税所得额超过第j级*/
　　　　　　S＝S+(paylevel[j]-paylevel[j-1])*taxPrate[j-1]/100；
　　　　　else{　S＝S+(__ (5)__)*taxPrate[j-1]/100；break；}
　　　}
　　　printf("职工％d应缴纳的个人所得税额：％10.21f\n"，employee[i].Id，S)；
　　　sum += S；
　　}
　　printf("全体职工个人所得税总额：％10，21f\n"，sum)；
　}

简答题

试题九
　　阅读以下应用说明及VisualBasic程序代码，将应填入__(n)__处的字句写在答题纸的对应栏内．
[应用说明9]
　　本应用程序的运行窗口如下图所示：

窗口中的三个文本框和两个按钮名称分别为Txt_salary、Txt_base、ht_tax、Cmd compute和Cmd_quit．运行时，文本框Txt_base中存放的是免税金额基数（应扣除的基本费用）。当用户在文本框ht_salary中输入月收入(工资或薪金)并单击“计算”按钮Crud_compute后，Txt_tax框中就显示计算所得的应纳税额。文本框Txt_base和Txt_tax在运行时不接受用户输入，Txt_base的内容以灰色显示。
　　个人工资(或薪金)所得税是按照超额累进的税率来征收的，方法是：以每月收入总额减去免税金额基数后的余额作为该月的月应纳税所得额，再将应纳税所得额按相应级数采用相应的税率进行累进计算．目前的免税金额基数为800元，税率如下表所示：
　　个人工资(或薪金)所得税是按照超额累进的税率来征收的，方法是：以每月收入总额减去免税金额基数后的余额作为该月的月应纳税所得额，再将应纳税所得额按相应级数采用相应的税率进行累进计算．目前的免税金额基数为800元，税率如下表所示：

　　设一个人的月应纳税所得额为K(元)，用下面的公式计算其应缴纳的个人所得税额S(元)：
　　若0<K≤500，则S=K×5％；
　　若500<K≤2000，则S=500×5％+(K—500)×10％：
　　若2000<K≤5000，则S=500×5％+1500×10％+(K-2000)×15％：
　　若5000<K≤20000，则S=500×5％+1500×10％+3000×15％+(K-5000)×20％：
　　例如，某人某月工资总额为4100元，减去800元后，应纳税所得额为3300元，其应缴纳的个人所得税额为500*5％+1500*10％+1300*15％=370元。
　　在开发过程中，需要编写的程序代码如下：
[程序代码]
　Option Base 0
　Private Sub Cmd compute-C1ick()
　　Dim paylevel，taxPrate
　　paylevel＝Array(0，500，2000，5000，20000，40000，60000，80000，100000，1000001)
　　taxPrate＝Array(5，10，15，20，25，30，35，40，45)
　　K＝__(1)__
　　S ＝ 0
　　If　(K>0)　Then
　　　For j＝1 To 9
　　　　If　__(2)__　Then
　　　　　S＝S+(paylevel(j)-paylevel(j-1))*taxPrate(j-1)/100
　　　　Else
　　　　　S＝S+(__(3)__)*taxPrate(j-1)/100
　　　　　Exit For
　　　　End lf
　　　Next j
　　End lf
　　__(4)__＝Str$(S)
　End Sub
　Private Sub Cmd_quit_C1ick()
　End
　End Sub
　Private Sub Form_Load()
　　Txt_tax.Text = " "
　　Txt_salary.Text = " "
　　Txt_base.Text = 800
　　Txt_tax.Locked = True
　　Txt_base.Enabled =__(5)__
　End Sub

简答题

试题一（15分，每空3分）
　　阅读下列说明和流程图，将应填入__(n)__的字句写在答题纸的对应栏内。
　　【流程图说明]
　　下面的流程图描述了对8位二进制整数求补的算法。
　　该算法的计算过程如下：从二进制数的低位（最右位）开始，依次向高位逐位查看，直到首次遇到“1”时，停止查看。然后，对该“1”位左面的更高位（如果有的话），逐位求反，所得的结果就是对原二进制数求补的结果。
　　例如：对二进制整数10101000求补的结果时01011000。
　　设8位二进制整数中的各位，从低位到高位，依次存放在整型数组BIT的BIT[1]～BIT[8]中。例如，二进制整数10101000存放在数组BIT后，就有BIT[1]＝0，BIT[2]=0,…,BIT[7]=0,BIT[8]=1。若流程图中存在空操作，则用NOP表示。

流程图中__(1)__处按“循环变量名：循环初值，增量，循环终值”格式描述。

简答题

试题二（15分，每空3分）
　　阅读下列说明和流程图，将应填入__(n)__的字句写在答题纸的对应栏内。
　　【函数说明】
　　函数sort（int a[]，int n）的功能时对数组a中的a[0]～a[n-1]这n个元素进行排序。排序过程如下：第一趟对所有的偶数下标p，比较a和a[p+1],若a＞a[p+1],则将两者交换；第二趟对所有的奇数下标q，比较a[q]和a[q+1]，若a[q]＞a[q+1]，则将两者交换；第三趟对偶数下标，第四趟对奇数下标，…，依次类推，直至整个数组元素有序排列为止。
　　【函数]
　　void sort (int a[],int n)
　　{
　　　int I ,j,t,tag=1;
　　　for(j=0;j＜n;j++＝ {
　　　　for (I=__(1)__;i＜n-1;__(2)__＝ {
　　　if (a＞a[I+1]) {t=a;a=a[I+1];a[I+1]=t;tag=0;}
　　　　}
　　　　tag++
　　　　if (__(3)__) break;
　　　}
　　}
　　对包含十个元素的数组a采用上述方法排序时，元素间的比较次数最少为__(4)__次，最多为__(5)__次。

简答题

试题三（15分，每空3分）
　　阅读下列说明和流程图，将应填入__(n)__的字句写在答题纸的对应栏内。
　　【函数说明]
　　函数movetoend（LinkedList La int i）的功能时：将线性表示A的第I个元素移到表尾。若移动成功，则返回0，否则返回-1。线性表A采用带头结点的单链表表示，La为表A的头指针，如下图所示。

链表结点的类型定义为：
　　typedef struct node {
　　　int key;
　　　struct node *next;
　　}*LinkedList
　　【函数]
　　int movetoend(LinkedList La,int i)
　　{
　　　LinkedList p ,q,prep;
　　　Int k=1;
　　　P=La->next;prep=La;
　　　While(__(1)__){　　　　　　/*查找第I个元素并使指针p指向该结点*/
　　　　Prep=p; p=p->next;k++
　　　}
　　　if (!p||k>i)return -1;
　　　if (__(2)__)　　　　　　　　/*第I个元素结点已经是表尾结点，则无需移动*/
　　　return 0;
　　　q=p;
　　　while(__(3)__)q=q-﹥next;　/*查找表尾并使q指向表尾结点*/
　　　__(4)__=p->next;
　　　p->next=NULL;
　　　__(5)__;
　　　return 0;
　　}

简答题

试题四（15分，每空3分）
　　阅读下列说明和流程图，将应填入__(n)__的字句写在答题纸的对应栏内。
　　【说明]
　　某单位举办了一场知识竞赛，参加竞赛的选手为300名，依次从1～300进行编号。竞赛时间为9：00～11：00。8道竞赛题目依次从‘A’～‘H’编号，选手可按任意次序答题，每完成一道题目，可立即提交答案。若答题正确（Y），则选择其他题目进行解答，否则，可继续做该题目或选择其他题目进行解答，直至竞赛结束。
　　选手提交答案的情况及判定结果由专人即时录入，录入的数据如下表1所示，对竞赛情况进行统计和排名的结果如表2所示。

统计和排名的规则如下：
　　1. 若选手X在竞赛时提交的题目P解答正确，2. 则解答该题目所用时间如下计算：
　　解答题目P的用时＝提交题目P正确的时间－竞赛的开始时间＋罚时
　　罚时＝提交题目P错误解答的次数×20
　　例如：表1中14号选手在10:27提交了题目A的正确解答，因此该选手正确解答该题目所用时间为87分钟，由于之前的两次提交错误解答，罚时为2×20＝40分钟，所以14号选手解答题目A的用时＝87＋40＝127（分钟）。
　　2．已经提交正确答案的题目再次提交时不再计算。
　　3．竞赛结束时，选手的总用时为所有解答正确的题目用时累加所得，解答不正确的题目不计时。
　　4．排名时，完成题目数量多者排名靠前；若完成的题目数相同，则用时少者排名靠前；若完成的题目数和所用时间均相等，则名次相同；完成题目数为0的选手不参加排名。
　　函数void Statistic()的功能是：读取输入数据，进行统计、排名并输出结果。
　　＃define MAXN 300
　　typedef struct {
　　　int no; /*选手编号*/
　　　int num; /*完成的题目数量*/
　　　int time; /*完成题目的总用时*/
　　　int d[8]; /*d用于记录提交第I个题目错误答案的次数*/
　　　int a[8]; /*a用于记录第I个题目是否已经提交正确答案*/
　　}Info;
　【函数】
　　void Statistic () {
　　　char ch,pass;
　　　int I,j,k,h,m,t,time,MaxIndex;
　　　Info R[MAXN+1];
　　　For(I=1;I<=MAXN;I++){ /*数组R的元素置初值0*/
　　　　R no=0; R num=0; R time=0;
　　　　For(j=0;j<8;j++){R.d[j]=0;R.a[j]=0;}
　　　}/*for*/
　　　MaxIndex=0;
　　　While(1) {
　　　　/*录入一名选手提交答案的信息（小时：分钟，选手编号，题目号，是否正确）*/
　　　　scanf(”%d:%d,%d,%c”,&h,&m,&k,&ch,&pass);
　　　　if (h= =0) break;
　　　　R[k] no=k;
　　　　Time=__(1)__;
　　　　If (isupper(ch)) ch=’a’+ch-‘A’;
　　　　If (pass !=’Y’&& pass !=’Y’) { R[k] d[ch-‘a’]++;continue;}
　　　　If (R[k] a[ch-‘a’]= =1) continue;
　　　　R[k] a[ch-‘a’]=1;
　　　　R[k] num++;
　　　　R[k] time+=__(2)__;
　　　　if (k>MaxIndex) MaxIndex=k;
　　　}　　　　　/*while*/
　　　for (I=1;I<MaxIndex;I++) {　　/*选择排序*/
　　　　for(t=I,j=I+1;j<=MaxIndex;j++)
　　　　if (R[t] num<R[j] num || __(3)__ t=j;)
　　　　if(__(4)__) { R[0]=R[t];R[t]=R[i];R[i]=R[0];}
　　　}　　/*for*/
　　　k=1;R[0]=R[1];
　　　for(I=1;I<=MaxIndex;I++) /*输出排名情况*/
　　　if(R[i]．num>0){
　　　　if (R num!=R[0].num || R[i].time!=R[0] time) k++;
　　　　R[0]=__(5)__;
　　　　Printf(“%d: %3d %4d %5d\n”,k,R no,R num R time);
　　　}　/*if*/
　　}　/*Statistic*/

简答题

试题五（15分，每空3分）
　　阅读下列说明及Visual Basic程序代码，将应填入__(n)__的字句写在答题纸的对应栏内。
　　【应用说明]
　　某单位举办了一场知识竞赛，参加竞赛的选手为300名，依次从1～300进行编号。竞赛时间为9：00～　11：00。8道竞赛题目依次从‘A’～‘H’编号，选手可按任意次序答题，每完成一道题目，可立即提交答案。若答题正确（Y），则选择其他题目进行解答，否则，可继续做该题目或选择其他题目进行解答，直至竞赛结束。
　　选手提交答案的情况及判定结果由专人即时录入，录入数据包括提交答案的时间、选手编号、题目编号（A～H）、是否正确（Y/N）。
　　对竞赛情况进行统计和排名的规则如下：
　　1.若选手X在竞赛时提交的题目P解答正确，则解答该题目所用时间如下计算：
　　解答题目P的用时＝提交题目P正确的时间－竞赛的开始时间＋罚时
　　罚时＝提交题目P错误解答的次数×20
　　例如：表1中14号选手在10：27提交了题目A的正确解答，因此该选手正确解答该题目所用时间为87分钟，由于他在09：37和09：52两次提交了题目A的错误解答，因此罚时为2×20＝40分钟，所以14号选手解答题目A的用时＝87＋40＝127（分钟）。
　　2.已经提交正确答案的题目再次提交时不再计算。
　　3.竞赛结束时，选手的总用时为所有解答正确的题目用时累加所得，解答不正确的题目不计时。
　　4.排名时，完成题目数量多者排名靠前；若完成的题目数相同，则用时少者排名靠前；若完成的题目数和所用时间均相等，则名次相同；完成题目数为0的选手不参加排名。
　　本应用程序的运行窗口如下图所示：

　　窗口中的两个文本框为Txt_time和Txt_player，分别用于录入提交答案的时间和选手编号。组合列表框Combol提供题目编号（A～H），录入时从中选择。检查框Chk_yn用于输入解答是否正确信息。当单击“确定”按钮（Cmd_comfirm）时，录入的提交信息加入列表框List1中，排名情况在列表框List2输出。单击“关闭”按钮时退出应用程序。
　　在开发过程中，需要编写的部分程序代码如下：
　　【程序代码]
　　Private Type Info
　　　No as integer ’选手编号
　　　Num as Integer ’完成题目数量
　　　Time as integer ’完成题目的总用时
　　　D(8) as integer ’d用于记录提交第i个题目错误答案的次数
　　　A(8) as Boolean ’a用于记录第i个题目是否已经提交正确答案
　　End type
　　Dim R(301) as info ’R[j]用于统计编号为j的选手提交答案的情况
　　Dim MaxIndex as Integer ’MaxIndex记录提交答案的选手中编号最大者
　　Private Sub From_Load ()
　　　For i=1 to 8
　　　　Combo1.additem chr(__(1)__)
　　　Next
　　　Combol.text = combol.list(0): txt_time .text=””: txt_player.text=””
　　　For i=1 to 300
　　　　R(i).num=0: R(i).time=0: R(i).no=i
　　　　For j=1 to 8
　　　　　R(i).d(j)=0: R(i).a(j)=false
　　　Next j,i
　　End Sub
Private sub cmd_confirm_click()
　　　Dim h, m,k, time as integer,ch ,pass,s1 as string
　　　K= Instr(txt _time .text,”:”):if k<2 then goto error1
　　　H=val(left(txt_time.text,k-1)):m=val(mid(txt_time.text,k+1))
　　　If h>11 or h=11 and m>0 or m>=60 then goto error1
　　　Time =__(2)__　　’计算答题时间，以分钟为单位
　　　If txt_plater.text<1 or txt_player .text>300 then goto error1
　　　Ch= __(3)__
　　　Pass=IIf(chk_yn.__(4)__ =0,”N”,”Y”)
　　　S1=txt_time.text+space(4)+txt_player.text
　　　S1=s1+space(10-len(txt_player.text))+ch+space(8)+pass
　　　List1.additem s1
　　　K= val(txt_player.text) 　　　　'k为选手编号
　　　R(k).no=k　　　　'编号为k的选手的提交信息记录在下标为k的数组元素中
　　　If k >maxindex then maxindex=k
　　　M = asc(ch)-asc(“a”)
　　　If pass <>”Y” then 　　　　　'编号为k的选手提交第m个题目的解答不正确
　　　　R(k).d(m)=R(k).d(m)+1
　　　Else if R(k).a(m)<>true then　　'已经提交正确的题目的解答不再计算
　　　　　R(k).a(m)=true:R(k).num=R(k).num+1
　　　　　R(k).time=R(k).time + __(5)__
　　　　　Call statistic　　　　　　　'调用过程statistic进行实时排名和输出
　　　End if
　　　Exit sub
　　　Error1:msgbox”录入信息有错误！”，vbOKOnly
　　End sub

简答题

试题六（15分，每空3分）
　　阅读以下说明和C++程序，将应填入 __(n)__处的字句写在答题纸的对应栏内
　　【说明】
　　以下程序的功能是计算三角形、矩形和正方形的面积并输出。
　　程序由4个类组成：类Triangle,Rectangle和Square分别表示三角形、矩形和正方形；抽象类Finure提供了一个纯虚拟函数getArea（），作为计算上述三种图形面积的通用接口。
　　【C++程序】
　　 #include<iostream.h>
　　 #include<math.h>
　　class Figure{
　　　public:
　　　virtual double getArea()=0;　　//纯虚拟函数
　　};
　　class Rectangle:__(1)__　{
　　　protected:
　　　double height;
　　　double width;
　　　public:
　　　Rectangle(){};
　　　Rectangle(double height,double width){
　　　　This->height=height;
　　　　This->width=width;
　　　}
　　　double getarea(){
　　　　return __(2)__ ;
　　　}
　　};
　　class Square:__(3)__　{
　　　public:
　　　square(double width){
　　　　__(4)__ ;
　　　}
　　};
　　class triangle:__(5)__　{
　　　double la;
　　　double lb;
　　　double lc;
　　　public:
　　　triangle(double la ,double lb,double lc){
　　　　this ->la=la; this->lb; this->lc;
　　　}
　　　double getArea(){
　　　　double s=(la +lb+lc)/2.0;
　　　　return sqrt(s*(s-la)**(s-lb) *(s-lc));
　　　}
　　};
viod main(){
　　　figure* figures[3]={
　　　　new triangle(2,3,3),new Rectangle(5,8),new Square(5)};
　　　　for (int i=0;i<3;i++){
　　　　　cout<<”figures[“<<i<<”]area= “<<(figures)->getarea()<<endl;
　　　　}
　　　}
　　 };

简答题

第七题（15分，每空3分）
　　阅读以下应用说明及VB部分的程序代码，将应填入__(n)__处的字句写在答题纸的对应栏内
　　【应用说明]
　　设一个简单的“通讯录”存储在一个Access类型的数据库表中，包括姓名、电话和email三个字段。下面的应用程序实现对“通讯录”数据库表中的记录进行增加、删除及修改处理，其运行界面如下：

　　（1）数据控件（data1）与"通讯录"数据库表相连接，用户可通过"》"和"《"按钮指定表中的当前记录。
　　（2）文本框txt_name,txt_phone和txt_email 分别与数据库中的姓名、电话和email字段绑定，用于显示当前记录的内容。
　　（3）应用程序启动时，"确定"按钮（cmd_ok）和"取消"按钮（cmd_cancel）不可操作，文本框中显示表中的第一条记录，这时文本框处于不可操作状态。
　　（4）单击"增加"按钮（cmd_add）或"修改"按钮（cmd_modify）后，方可以编辑记录内容，同时增加、删除、修改和退出按钮变为不可操作状态。增加和修改操作需通过确定和取消按钮确认。
　　（5）单击删除按钮（cmd_del）后，弹出对话框，再单击确定按钮，当前记录被删除。
　　【程序代码】
　　private sub enableop(isenabled as Boolean)
　　　txt_name.enabled=isenabled :txt _phone.enabled=isenabled
　　　txt_email.enabled=isenabled
　　　cmd_ok.enabled= isenabled: cmd_cancel.enabled= isenabled
　　　cmd_add.enabled= not isenabled: cmd_del.enabled= not isenabled
　　　cmd_end.enabled= not isenabled: cmd_modify.enabled= not isenabled
　　end sub
　　private sub form_load()
　　　call enableop(false)
　　　detal.refresh
　　　if data1.recordset.recordcount=0 then
　　　　cmd_del.enabled= false: cmd_modify.enabled= __(1)__
　　　end if
　　end sub
　　private sub cmd_add_click() 　　'单击“增加”按钮的代码
　　　call enableop( __(2)__ )
　　　data1.recordset.addnew　　　　'在数据库表中添加一个新记录
　　　txt_name.__(3)__
　　end sub
　　private sub cmd_del_click()　　'单击“删除”按钮的代码
　　　on error goto error3
　　　ans=msgbox(“确定删除吗？”，vbYesNo+vbInformation,” 操作提示！”)
　　　if (ans=vbyes) then
　　　　data1.recordset.__(4)__
　　　　data1.recordset.movenext
　　　　if data1.recordset.Eof then data1.refresh
　　　end if
　　　exit sub
　　　error3:
　　　msgbox err.description,vbokonly,”错误提示！”
　　end sub
private sub cmd_ok_click() 　　　'单击确定按钮的代码
　　　on error goto error1
　　　data1.recordset.__(5)__
　　　call enableop(false)
　　　exit sub
　　　error1:
　　　msgbox err.description,vbokonly,”错误提示！”
　　　data1,updatecontrols
　　call enableop(false)
　　end sub
　　'修改和取消按钮的程序代码略

简答题

试题八（15分，每空3分）
　　阅读以下说明和Java程序，将应填入__(n)__处的字句写在答题纸的对应栏内
　　【说明】
　　以下程序的功能时三角形、矩形和正方形的面积输出。
　　程序由5个类组成：areatest是主类，类Triangle,Rectangle和Square分别表示三角形、矩形和正方形，抽象类Figure提供了一个计算面积的抽象方法。
　　【程序】
　　public class areatest{
　　　public static viod main(string args[]){
　　　　Figure[]Figures={
　　　　　New Triangle(2,3,3),new rectangle(5,8),new square(5)
　　　　};
　　　　for (int i= 0;i< Figures.length;i++){
　　　　　system.out.println(Figures+”area=”+ Figures.getarea());
　　　　}
　　　}
　　}
　　public abstract class figure{
　　　public abstract double getarea();
　　}
　　public class rectangle extends __(1)__ {
　　　double height;
　　　double width;
　　　public rectangle (double height, double width){
　　　　this.height= height;
　　　　this. width = width;
　　　}
　　　public string tostring(){
　　　　return”rectangle: height=”+ height +”, width=”+ width +”:”;
　　　}
　　　public double getarea(){
　　　　return __(2)__
　　　}
　　}
　　public class square exends __(3)__
　　{
　　　public square(double width) {
　　　　__(4)__ ;
　　　}
　　　public string tostring(){
　　　　return” square:width=”+width”:”;
　　　}
　　}
public class rectangle entend __(5)__
　　{
　　　double la;
　　　double lb;
　　　double lc;
　　　public triangle(double la ,double lb,double lc){
　　　　this.la=la; this.lb=lb; this.lc=lc;
　　　}
　　　public string tostring(){
　　　　return” triangle:sides=”+la+”, ”+lb+”, ”+lc+”:”;
　　　}
　　　public double get area(){
　　　　double s=(la+lb+lc)/2.0;
　　　　return math.sqrt(s*(s-la) *(s-lb) *(s-lc));
　　　}
　　}

简答题

试题一（15分，每空3分）
　　阅读以下说明和流程图，回答问题1至问题2将解答填入答题纸的对应栏内。
[说明]
　　设8位二进制代码 B0B1...B7中的最高位B0为奇偶校验位。对于任何给定的代码B1B2...B7，可按下式计算偶校验位：
　　　　B0= B1⊕B2⊕…⊕B7
　　其中，"⊕"表示"异或"运算。
　　下面的流程图描述了计算偶校验位的过程。
[流程图]

　　注：流程图，循环开始的说明按照"循环变量名：循环初值，循环终值，增量"格式描述。
[问题1]
　　将流程图中的（1）～（4）处补充完整。
[问题2]
　　若按下式计算奇校验位，则上述流程图中的（1）处应填（5）。
　　　　B0= B1⊕B2⊕…⊕B7⊕1

简答题

试题二（15，每空3分）
　　阅读以下函数说明和C语言函数，将应填入___(n)___处的字句写在答题纸的对应栏内。
[函数2.1说明]
　　函数int funl (int m, int n)的功能是：计算并返回正整数m和n的最大公约数。
[函数2.1]
　　int funl (int m, int n)
　　{
　　　while (___(1)___){
　　　　if(m﹥n) m=m-n;
　　　　else n= n-m;
　　　}
　　　___(2)___;
　　}
[函数2.2说明]
　　函数long fun2(char*str)的功能是：自左至右顺序取出非空字符串str中的数字字符形成一个十进制整数（最多8位）。
　　例如，若字符串str的值为"f3g8d5.ji2e3p12fkp",则函数返回值为3852312。
[函数2.2]
　　long fun2(char *str)
　　{ int i=0;
　　　long k=0;
　　　char *p=str ;
　　　while (*p != '/0'&& (3) ) {
　　　　if(*p ?='0'&& *p ?='9'){
　　　　　k=___(4)___+*p-'0'；
　　　　　++i；
　　　　}
　　　　___(5)___；
　　　}
　　　Return k；
　　}

简答题

试题三（15分，每空3分）
　　阅读以下说明和C语言函数，将应填入___(n)___处的字句写在答题纸的对应栏内。
[说明]
　　一棵非空二叉树中"最左下"结点定义为：若树根的左子树为空，则树根为"最左下"结点；否则，从树根的左子树根了发，沿结点的左孩子分支向下查找，直到某个结点不存在左孩子时为止，该结点即为此二叉树的"最左下"结点。例如，下图所示的以A为根的二叉树的"最左下"结点为D，以C为根的子二叉树中的"最左下"结点为C。

　　二叉树的结点类型定义如下：
　　typedef struct BSTNode{
　　　int data;
　　　struct BSTNode *lch ,*rch;　　//结点的左、右孩子指针
　　}*BSTree;
　　函数BSTree Find_Del (BSTree root)的功能是：若root 指向一棵二叉树的根结点，则找出该结点的右子树上的"最左下"结点*p，并从树下删除以*p为根的子树，函树返回被删除子树的根结点指针；若该树根的右子树上不存在"最左下" 结点，则返回空指针。
[函数]
　　BSTree Find_Del (BSTree root)
　　{ BSTree p,pre；
　　　if (!root)return NULL；　　　/*root指向的二叉树为空树*/
　　　___(1)___；　　　　　　　　　/*令p指向根结点的右子树*/
　　　if (!p) return NULL；　　　　/*设置pre的初值*/
　　　___(2)___；　　　　　　　　　/*查到"最左下"结点 */
　　　Pre=p；p=___(3)___；
　　}
　　if (___(4)___ == root)　　　　　/*root的右子树根为"最左下"结点*/
　　　pre -> rch = NULL；
　　else
　　　___(5)___ = NULL；　　　　　　/*删除以"最左下"结点为根的子树*/
　　return p；
　　}

简答题

试题四（15分，每空3分）
　　阅读以下说明和C语言函数，将应填入___(n)___处的字句写在答题纸的对应栏内。
[说明]
　　假设一个剧场有N*N个座位，顾客买票时可以提出任意有效的座号请求。下面用二维数组a[N] [N],模拟剧场中的座位，a[i] [j]等于0表示第i排第j列（0≤I,j≤N－1）的票尚未售出。
　　函数 int Find(int a [][N]，int R，int*row，int *col)的功能是：在部分票已售出的情况下，找出剧场中的R*R个空座位，要求这些座位的排列形成一个正方形。若找到满足要求的一个座位排列，则函数返回1，并算出该正方左上角的行、列号；若未找到，返回0。
　　例如，一个7×7个座位的剧场如下图（a）所示，已售出部分座位的剧场如下图（b）所示，图中阴影部分表示已售出的座位，从图（b）中找出的3×3正方形空座位如图（c）中斜线区所示。

[函数]
　　int Find(int a[][N],int R ,int *row,int*col)
　　{ int i,j,k,c,t；int FOUND=0;
　　　for (i=0；!FOUND && i ＜N-R+1;i++){　　　　　　/*从第0排开始查找*/
　　　　___(1)___；
　　　　while(j<N-R+1 && !FOUND) {
　　　　　for(k=0；___(2)___ && a[i][j+k]==0；k+1；　/*查找第i排连续的R个空座位*/
　　　　　if(k>=R){　　　　　　　　　　　　　　　　　/*找到第i排连续的R个空座位*/
　　　　　　for(c=0；c<R；c++){　　　　　　　　　　　/查找其余的R*（R-1）个座位*/
　　　　　　　for(t=1；t<R； t++)
　　　　　　　if (a[___(3)___][j+c] != 0break；
　　　　　　　if (t<R) break；
　　　　　　}/*for*/
　　　　　　If (___(4)___) FOUND=1；
　　　　　}　　　　　　　　　/* if*/
　　　　　___(5)___；
　　　　}　　　　　　　　　　/*while*/
　　　}　　　　　　　　　　　/*for i*/
　　　if (FOUND){
　　　　*row = i-1； *col = j-1； /*计算正方形区域的左上角坐标*/
　　　　return 1；
　　　}
　　　return 0；
　　}

简答题

试题五（15分，没空3分）
　　阅读以下说明及Visual Basic 程序代码，将应填入___(n)___处的字句写在答题纸的对应栏内。
[说明]
　　甲乙两地之间的铁路线上有二十多个火车站，为方便乘客查询票价，特开发了火车票价查询程序，其运行窗口如下图所示，乘客只要通过两个下拉列表框分别选择起点与终点站名，再单击"查询"按钮，则票价文本框中就会显示相应的票价。

　　在开发过程中，设选择起点和终点站名的组合框（ComboBox）名分别为ST和SP，显示票价的文本框（TextBox）名为Price，"查询"按钮（CommandButton）名为Query；设ST与SP中的诸列表项完全相同，且都是从甲地开始依次排列，从第i站到第j站的票价存放在二维对称矩陈P的元素P(i,j)中，假设从甲地到第i站行驶的距离存放在d(i)中，火车票价等于其行驶距离乘以C（常数）。
[Visual Basic代码]
　　Dim p(30,30) As Single　　　　'通用声明
　　Const C=0.2
　　Private Sub Form load()
　　　Dim d(30) As Single
　　　___(1)___="甲地"　　　　　　　'在ST组合框中设置首个列表项
　　　……　　　　　　　　　　　　　'在ST和SP中设置其他列表项（若干行语句）
　　　……　　　　　　　　　　　　　'对数组d(i)赋值（若干行语句）
　　　For i=0 to ST.___(2)___ -1　　'对ST中各列表项循环
　　　　For j=0 to SP.___(2)___ -1　'对SP中各列表项循环（这两处填写内容相同）
　　　　　P（i，j）= ___(3)___
　　　　Next j
　　　Next i
　　End Sub
　　Private Sub query_Click()
　　　i= ___(4)___　　　　　　　　　'组合框ST中选择的当前项编号
　　　j=……　　　　　　　　　　　　'组合框SP中选择的当前项编号（语句略）
　　　___(5)___ = str﹩(p(i,j))
　　End Sub

简答题

试题六（15分，每空3分）
　　阅读以下说明、Java代码和HTML文档，将应填入___(n)___处的字句写在答题纸的对应栏内。
[说明]
　　当用户启动html浏览器并首次打开下面的html文档时，Java Applet小程序在显示面板上显示字符串"Welcome!"；当html页面被其它窗口遮挡后再次显示时，小程序在显示面板上显示"Welcome back!"。
[Java代码]
　　import java.awt.*；
　　import java.applet.*；
　　public class HelloApplet extends ___(1)___{
　　　public void paint( ___(2)___){
　　　　g.drawString(message,10,20)；
　　　　message ="welcome back!"；
　　　}
　　　Public void ___(3)___(){
　　　　message="Welcome!" ；
　　　}
　　　Private ___(4)___ message；
　　}
[HTML文档]
　　<html>
　　<head>
　　　<title>HTML Test HelloApplet Page</title>
　　</head>
　　<body>
　　　Test HelloApplet 小程序〈br>
　　　<applet
　　　　codebase="."
　　　　code=" ___(5)___ "
　　　　name="TestApplet"
　　　　width="400"
　　　　height="300"
　　　>
　　　</applet>
　　　</body>
　　</html>

简答题

试题七（15分，每空3分）
　　阅读以下说明及Visual Basic 程序代码，将应填入___(n)___处的字句写在答题纸的对应栏内。
[说明]
　　某个文本件中存放了若干个非零数值有效数据，每个数据占一行，最后一行以数字"0"作为结束标志。下面的程序用于计算该文件中这些数据之和，其运行窗口如下：

　　用户只要通过驱动器列表框、目录列表框和文件列表框，选择文本文件所在的驱动器、文件夹及相应的文件名，再单击"累计"按钮，就能在"总计"文本框中看到该文本文件中的数据之和。
　　在开发过程中，设驱动器列表框名为Drivel,目录列表框名为Dirl，文件列表框名为Filel,存放数据的文本文件名为D：/text/vb7/data.txt,"累计"按钮名为sum,"总计"文本框（TextBox）名为textl。
[Visual Basic 代码]
　　Private Sub Drivel_Change()
　　　Dirl.Path=___(1)___'用户选择的驱动器反映到目录列表框中
　　End Sub
　　Private Sub Dirl_Change()
　　　Filel.Path=___(2)___'用户选择的文件改变文件列表框内容
　　End Sub
　　Private Sub sum_Click()
　　　Dim ___(3)___ As New FileSystemobject,___(4)___ As TextStream
　　　'创建自己的文件系统对象，说明自己的文本流对象
　　　If Right(Dirl.Path,1)=″/″ Then
　　　　SetmyTextFile=fso.OpenTextFile(Dirl.Path+Filel.FileName)
　　　Else
　　　　SetmyTextFile=fso.OpenTextFile(Dirl.Path+″1″+Filel.FileName)
　　　End If
　　　S=0
　　　Do
　　　　d=Val(myTexFile.ReadRow)
　　　　S= S+d
　　　　Loop While ___(5)___
　　　Textl.Text=Str$(S)
　　End Sub

简答题

试题八（15分，每空3分）
　　阅读以下说明和C++程序，将应填入___(n)___处的字句写在答题纸的对应栏内。
[说明]
　　下面程序的功能是计算并输出某年某月的天数。
[C++程序]
　　 #include<iostream>
　　using namespace std；
　　___(1)___ Month{Jan,Feb,May,Jun,Jun,Jul,Aug,Sep,Oct,Nov,Dec}；
　　class Date{
　　　public；
　　　Date(int year, Month m_month){
　　　　___(2)___ = year；
　　　　if(m_month<Jan|| m_month>Dec)month=Jan；
　　　　else month=m_month；
　　　}；
　　　～Date(){};
　　　bool IsLeap Year(){
　　　　return ((year % 4 == 0 && year % 100 != 0||year % 400==0)；
　　　}；
　　　Int CaculateDays(){
　　　　Switch (___(3)___){
　　　　　Case Feb: {
　　　　　　If (___(4)___)return29;
　　　　　　else return28;
　　　　　}
　　　　　case Jan: case Mar: case May: case Jul: case Aug: case Oct:
　　　　　case Dec:return31:
　　　　　case Apr: case Jun: case Sep: case Nov: return30；
　　　　}
　　　}；
　　　Private:
　　　int year;
　　　Month month;
　　}；
　　Void main (){
　　　Date day (2000,Fed);
　　　Cort << day.___(5)___()；
　　}

简答题

试题一（15分，每空3分）
　　阅读下列说明和流程图，将应填入___(n)___处的字句写在答题纸的对应栏内。
[流程图说明]
　　流程图1-1描述了一个算法，该算法将给定的原字符串中的所有前导空白和尾部空白都删除，但保留非空字符的空白。例如，原字符串" File Name "，处理变成"File Name" 。流程图1-2、流程图1-3 、流程图1-4分别详细描述了流程图1-1中的框A、B、C。
　　假设原字符串中的各个字符依次存放在字符数组ch 的各元素ch(1) 、ch(2) 、?、ch(n) 中，字符常量KB表示空白字符。
　　流程图1-1的处理过程是：先从头开始找出该字符串中的第一个非空白字符ch(i)，再从串尾开始向前找出位于最末位的非空白字符ch(j) ，然后将ch(i) 、?、ch(j) 依次送入ch(1) 、ch(2)、?中。如果字符串中没有字符或全是空白字符，则输出相应的说明。在流程图中，strlen 是取字符串长度函数。
[流程图1-1]

[流程图1-2]

[流程图1-3]

[流程图1-4]

[问题]
　　在流程图1-1中，判断框P中的条件可表示为：i > ___(5)___

简答题

试题二（15，每空3分）
　　阅读以下函数说明和C语言函数，将应填入___(n)___处的字句写在答题纸的对应栏内。
[说明]
　　函数int find_Max_Min(int a[ ],int n) 的功能是：找出n个元素的数组a中的最大元素和最小元素并输出，返回查找过程中元素的比较次数。查找方法如下：比较a[0] 和a[n-1], 若a[0] 大，则交换a[0] 和a[n-1] 的值；再比较a[1] 和a[n-2] ，若a[1] 大，则交换a[1] 和a[n-2] 的值；依此类推，直到所有的元素都比较完。然后在数组的前半区从前往后找出小元素，在后半区从后往前找出大元素。
[函数]
　　int find_Max_Min(int a[ ],int n) {
　　　/* 找出n个元素的数组a中的最大元素、最小元素并输出，返回查找过程中元素的比较次数*/
　　　int i,Count = 0;
　　　int temp,Maxnum,Minnum;
　　　for(i = 0; i < n/2; i++){
　　　　Count = Count + 1;　　　　　　/*元素比较次数计数*/
　　　　if(a[i]>a[_____(1)_____ ]
　　　　{　/* 数组元素交换代码略*/　}
　　　}
　　　Maxnum=a[n-1];
　　　Minnum=a[0];
　　　for(i = 1; i < n/2+ n%2; i++){
　　　　Count = _____(2)_____ ;　　　　　　　　　　　　　/* 元素比较次数计数*/
　　　　Minnum = _____(3)_____ ? a[i]:Minnum;　　　　　　/*找出最小元素*/
　　　　Maxnum = _____(4)_____ ? _______(5)_____:Maxnum; /* 找出最大元素*/
　　　} printf("Max=%d\n,Maxnum"); printf("Min=%d\n",Minnum); return Count;
　　}

简答题

试题三（15分，每空3分）
　　阅读以下说明和C语言函数，将应填入___(n)___处的字句写在答题纸的对应栏内。
[说明]
　　某种传感器的输出值Ratio 依赖于环境温度temp(-40℃≦temp≦50℃)。对一组环境温度值（ITEMS 个），人们已经测量得到了相应的Ratio 值（见表1）。该表粗略地描述了曲线Ration(temp) 。

　　校正系数K是Ratio 的倒数，因此也依赖于环境温度temp 。在数据处理中，人们需要用更多的列表值细致地描述曲线K（temp ），如表2所示。在表2中，各温度值所对应的K值是对表1进行线性插值再求倒数得到的，具体的计算方法如下：
　　1. 根据temp 值，在表1中用二分法查找；
　　2. 若找到相应的温度值，则按相应的Ratio 值求倒数得到K值；
　　3. 若没找到相应的温度值，则可确定temp 所在的温度区间[Tp1,Tp2] ，同时获得了相应的Ratio1 和Ratio2 ，再按如下公式计算K值：
　　　Step = (Ratio1 - Ratio2)/(Tp1 - Tp2)
　　　K = 1.0/(Ratio1 + Step * (temp - Tp1))
　　在程序中，当temp 高于50℃或低于-40℃时，设定K=0。
[程序]
　　 #include <stdio.h> typedef struct{
　　　　int Temp;　　　/*环境温度*/
　　　　double Ratio;　/*传感器的输出值*/
　　 }CURVE;
　　#define ITEMS 7
　　double GetK(int,CURVE *,int);
　　void main()
　　{ int Degree;
　　　double k;
　　　CURVE Curve[ITEMS] = {{-40,0.2},{-20,0.60},{-10,0.8},{0,1.0},
　　　　　　　　　　　　　　{10,1.17},{30,1.50},{50,1.8}};
　　　printf(" 环境温度校正系数\n");
　　　for(Degree = -40;Degree <= 50; Degree++){
　　　　k = GetK(Degree,Curve,ITEMS);
　　　　printf("%3d %4.2f\n",Degree,k);
　　　}
　　}
　　double GetK(int Temp,CURVE *p,int n)
　　{　　/* 用二分法在n个元素的有序表p中查找与Temp 对应的传感器输出值*/
　　　int low,high,m;
　　　double Step;
　　　low = 0;
　　　high = n-1;
　　　if ((Temp < p->Temp)||(Temp > (p+high)->Temp))
　　　　return 0.0;　　/* 超出温度范围时返回0.0*/
　　　while (low <= high){
　　　　m =_____(1)_____;
　　　　if (Temp == (p+m)->Temp)
　　　　　return _____(2)_____ ;
　　　　if (Temp < (p+m)->Temp) high = m-1;
　　　　else low = _____(3)_____ ;
　　　}
　　　p += high; Step = (_____(4)_____)/((p+1)->Temp - p->Temp);
　　　return 1.0/(p->Ratio + Step * (_____(5)_____));
　　}

简答题

试题四（15分，每空3分）
　　阅读以下应用说明以及用Visual Basic 开发过程中进行的属性设置和所编写的程序代码，将应填入_____(n)_____处的字句写在答题纸的对应栏内。
[应用说明]
　　启动某应用程序运行的登录窗口如下：

其中的标签（Label1）"用户名（U）"对应文本框 Username ，标签（Label2）"密码（P）"对应文本框"Password" 。当用户在Username 文本框中输入用户名"ali88" ，在Password文本框中输入"zmkm"( 显示的字符均为"*") ，并单击"确定"按钮时，就会弹出应用程序的主窗口frmAPP ，而该登录窗口就会卸载。
　　如果用户名或密码输入错误，则会弹出报警信息框。当用户单击其中的"确定" 按钮后，登录窗口"Password" 文本框的内容就会消失，光标停留在该框内，以便用户重新输入密码，必要时用户还可以再修改用户名，再次做登录尝试。本应用程序允许发生3次输入错误。在第3次输入错误后，就会立即退出该应用程序。
　　在弹出登录窗口后，当按键"Alt+U" 时光标就会停留在Usename 文本框中；当按键"Alt+P" 时光标就会停留在Password文本框中。当用户按"Enter" 键时，就相当于单击"确定"按钮；当用户按"Esc"键时，就相当于单击"取消"按钮，立即退出该应用程序。
[属性设置]
　　在开发过程中，部分控件及属性设置如下：

[程序代码]
　　Private Sub cmdOK_Click()
　　　_____(3)_____ As Integer　　　'静态变量time 的说明
　　　If ___(4)___ Then
　　　　Unload Me 　　　　　　'卸载本登录窗口
　　　　____(5)_____　　　　　'弹出应用程序主窗口frmAPP
　　　Else
　　　　MsgBox(" 用户名密码错！")
　　　　Times = times+1
　　　　Password.Text = ""　　'清除密码框中的内容
　　　　Password.SetFocus　　 '将光标定位于密码框
　　　If times = 3 Then
　　　　End
　　　End If
　　End Sub
　　Private Sub
　　　cmdCancel_Click()
　　　End
　　End Sub

简答题

试题五（共15分）
　　阅读以下说明和C语言函数，将应填入__(n)__ 处的字句写在答题纸的对应栏内。
[说明]
　　二叉排序树或者是一棵空树，或者是具有如下性质的二叉树：若它的左子树非空，则左子树上所有结点的值小于根结点的值；若它的右子树非空，则右子树上所有结点的值均大于根结点的值；左、右子树本身就是两棵二叉排序树。
　　函数insert_BST(char *dtr) 的功能是：对给定的字符序列按照ASCII 码值大小关系创建二叉排序树，并返回指向树根结点的指针。序列中重复出现的字符只建一个结点，并由结点中的Count域对字符的重复次数进行计数。
　　二叉排序树的链表结点类型定义如下：
　　typedef struct BSTNode{
　　　char Elem;　　　　/* 结点的字符数据*/
　　　int Count;　　　　/*记录当前字符在序列中重复出现的次数*/
　　　struct BSTNode *Lch,*Rch;　　/* 结点的左、右指针*/
　　}　*BiTree;
[函数]
　　BiTree insert_BST(char * str) {
　　　BiTree root,parent,p;
　　　char _______(1)________;　　/*变量定义及初始化*/
　　　root = (BiTree)malloc(sizeof(struct BSTNode));
　　　if (!root || *s=='\0') return NULL;
　　　root->Lch = root->Rch = NULL;
　　　root->Count = 1;
　　　root->Elem = *s++;
　　　for(;*s != '\0';s++){
　　　　______(2)______;
　　　　parent = NULL;
　　　　while (p) {
　　　　/*p从树根结点出发查找当前字符*s所在结点*/
　　　　　parent = p;
　　　　if (*s == p->Elem)　　/*若树中已存在当前字符结点，则当前的字符计数值加1*/
　　　　{ p->Count++; break;}
　　　　else　　　/*否则根据字符*s与结点*p中字符的关系，进入*p的左子树或右子树*/
　　　　　if (*s > p->Elem) p = p->Rch;
　　　　　else p = p->Lch;
　　　　}　/*while*/
　　　　if (______(3)_____) { /*若树中不存在字符值为*s的结点，则申请结点并插入树中*/
　　　　　p = (BiTree)malloc(sizeof(struct BSTNode));
　　　　　if (!p) return NULL;
　　　　　　p->Lch = p->Rch = NULL;
　　　　　　p->Count = 1;
　　　　　　p->Elem = *s;
　　　　　　/*根据当前字符与其父结点字符值的大小关系，将新结点作为左子树或右子树插入*/
　　　　　if (p->Elem > parent->Elem) ______(4)_____ = p;
　　　　　else _________(5)________ = p;
　　　　}
　　　}　　/*for*/
　　　return root;
　　}

简答题

试题六（共15分）
　　阅读以下说明和C++代码，将解答写入答题纸的对应栏内。
[说明]
　　类Stock的定义中有三处错误，分别在代码的第04、06、10行。请补齐下述代码中的空缺1，修改错误并给处修改后该行的完整代码，最后完善程序运行后的输出结果。
[C++ 代码]

　　程序运行后的输出结果为：
　　1:3.5
　　_____(2)_____
　　_____(3)_____

简答题

试题七（15分）
　阅读以下应用说明以及用Visual Basic 编写的程序代码，将应填入_____(n)_____ 处的字句写在答题纸的对应栏内。
[应用说明]
　　本应用程序的运行窗口中将显示一个简单的模拟时钟如下：

　该圆形钟面上有时针、分针和秒针在运动，不断显示系统的当前时间。
　　在开发该喁喁时，首先建立一个圆形Shape 控件作为钟面（背景为白色）。设圆心为象素坐标（X0，Y0），半径为940。再在圆心处建立一个小的实心圆Shape控件作为轴心。钟面上的刻度3，6，9，12为四个标签。时针、分针、秒针（红色）为线型控件，名称分别为LineH 、LineM、LineS ，线宽属性值分别为：3，2，1，线长属性值分别为500，700，900。这三个线型控件的起点坐标都固定在（X0，Y0）其终点坐标随转角θ而动态变化：

　设置定时器Timer1 使该时钟能反映系统的当前时间，其定时间隔为0.5秒，该定时器的Interval 属性值应设置为_____(1)_____ 。每隔0.5秒，秒针需要调整位置，但分针和时针只是在初始显示时以及在每次秒计数为0时才需要调整位置（可节省计算量）。
[程序代码]
　　Const Pi = 3.1416
　　Const X0 = 1750
　　Const Y0 = 1150
　　Const LH = 500, LM = 700, LS = 900 Public first As Boolean
　　Private Sub Form_Load()
　　　LineS.X1 = X0　　'秒针的起点位置
　　　LineS.Y1 = Y0
　　　LineM.X1 = X0　　'分针的起点位置
　　　LineM.Y1 = Y0
　　　LineH.X1 = X0　　'时针的起点位置
　　　LineH.Y1 = Y0
　　　first = True
　　End Sub
　　Private Sub Timer1_Timer()
　　　S = Second(Time)
　　　S_seta = Pi *
　　　______(2)______　　'秒针的转角
　　　LineS.X2 = X0 + LS * Sin(S_seta)　　　'秒针的终点位置
　　　LineS.Y2 = Y0 -LS * Cos(S_seta)
　　　If (____(3)_____) Then
　　　　M = Minute(Time)
　　　　LineM.X2 = X0 + LM * Sin(Pi*M/30)　　'分针的终点位置
　　　　LineM.Y2 = Y0 - LM * Cos(Pi*M/30)
　　　　H = Hour(Time)
　　　　If (H >= 12) Then H = H -12
　　　　H_seta = Pi * (______(4)______)　　'时针的转角
　　　　LineH.X2 = X0 + LH * Sin(H_seta)　'时针的终点位置
　　　　LineH.Y2 = Y0 - Lh * Cos(H_seta)
　　　　first = ________(5)________
　　　End If
　　End Sub

简答题

试题八（共15分）
　　阅读以下说明和Java代码，将解答写入答题纸的对应栏内。
[说明]
　　已知类Stock和类JavaMain 都定义在JavaMain.java 文件中，类Stock 的定义中有四处错误，分别在代码的第01、02、06、07行。请修改错误并给出修改后该行的完整代码，并写出改正错误后程序运行的输出结果。
[Java 代码]

简答题

试题一(共15分)
　　阅读以下说明和流程图，回答问题1至问题3，将解答填入答题纸的对应栏内。
[说明]
　　信息处理过程中经常需要将图片或汉字点阵做旋转处理。一个矩阵以顺时针方向旋转90°后可以形成另一个矩阵，如下图所示:

　　流程图1-1描述了对n*n矩阵的某种处理。流程图1-2是将矩阵A顺时针旋转90°形成矩阵B的具体算法。
[流程图1-1]　　　 [流程图1-2]

[问题1](3分)
　　请写出以下3*3单位矩阵沿顺时针方向旋转90°后所形成的矩阵。
　　

　　　
[问题2](3分)
　　如果以下3*3矩阵沿顺时针方向旋转90°后所形成的矩阵就是原来的矩阵：
　　

　
　其中，位于*处的元素需要考生填写
　　请完整地写出该矩阵。
[问题3](9分)
　　在上述流程图1-1和1-2的算法中，
　　(1)矩阵A第i行第j列的元素A(i,j)被复制到矩阵B中的哪个位置?
　　(2)A(i,j)后来又被复制到矩阵C中的哪个位置?
　　(3)填补流程图1-2中的空缺。

简答题

试题二(共15分)
　　阅读以下说明和C语言函数，将应填入__(n)__处的字句写在答题纸的对应栏内。
[说明]
　　函数chanse(int num)的功能是对四位以内（含四位）的十进制正整数num进行如下的变换：将num的每一位数字重复一次，并返回变换结果。例如，若num=5234，则函数的返回值为55223344，其变换过程可描述为：
　　　(4*10+4)*1 + (3*10+3)*100 + (2*10+2)*10000 + (5*10+5)*1000000 = 55223344
[C语言函数]

　　long change (int num)
　　{
　　　int d, m =num;
　　　long result, mul;
　　　if (num <= 0 || [__(1)__) 　　/*若num不大于0或num 的位数大于4，则返回-1*/
　　　　return -1;
　　　mul = 1;
　　　__(2)__;
　　　while (m > O) {
　　　　d = m % 10;
　　　　m = __(3)__;
　　　　result = result + (__(4)__) * mul;
　　　　mul = __(5)__;
　　　}
　　　return result;
　　}

1 2 3