阅读以下说明和C语言函数，将应填入（n)处的字句写在对应栏内。【说明】 将A，B，C，D，E，F这6个变量排成

阅读以下函数说明和C语言函数，将应填入(n)处的字句写在对应栏内。

【函数2.1】

void sort(char *s,int num)

{int i,j--num;

char t;

while(j--＞1)

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

if(s[i]＞s[i+1])

{t=s[i];

s[i]=s[i+1];

s[i+1]=t;

}

void main()

{char *s="CEAedea";

sort(s,5);

printf("%s",s);

}

上述程序的结果是(1)

【函数2.2】

void main()

{ union {int ig[6];

Char s[12];} try;

try. ig[0]=0x4542; try.ig[1]=0x2049;

try. ig[2]=0x494a; try.ig[3]=0x474e;

try. ig[4]=0x0a21; try.ig[5]=0x0000;

pintf("%s",try, s);

}

上述程序的结果是(2)

【函数2.3】

void main()

{ char *letter[5]= { "ab","efgh","ijk","nmop","st"};

char **p;

int i;

p=letter;

for(i=0;i＜4;i++) .

printf("%s",p[i]);

}

上述程序的结果是(3)

【函数2.4】

main()

{int i=4,j=6,k=8,*p=&I,*q=&j,*r=&k;

int x,y,z;

x=p==&i;

y=3*-*p/(*q)+7;

z=*(r=&k)=*p**q;

printf("x=%d,y=%d,z=%d",x,y,z);

}

上述程序的结果是(4)

【函数2.5】

int a[]={5,4,3,2,1 };

void main()

{int i;

int f=a[0];

int x=2;

for(i=0;i＜5;i++)

f+=f*x+a[i];

printf("%d",f);

}

上述程序的结果是(5)

阅读下列函数说明和C函数，将应填入(n)处的字句写在对应栏内。

[说明]

链式存储的队列称为链队。根据队列的FIFO原则，为了操作上的方便，可以使用带头指针front和尾指针rear的单链表来实现链队。若链队元素的数据类型为datatype，则链队结构描述如下：

typedef struct node

{ datatypedata;

structnode *next;

} QNode; /*链队结点的类型*/

typedef struct

{ QNnode *front,*rear;

} LQueue; /*将头尾指针封装在一起的链队*/

以下这种链队的几个例子：

设q是一个指向链队的指针，即LQueue *q。下面各函数的功能说明如下：

(1) LQueue *Init_LQueue()：创建并返回一个带头尾结点的空链队；

(2) intEmpty_LQueue( LQueue *q):判断链队q是否空；

(3) void In_LQueue(LQueue *q, datatypex):将数据x压入链队q；

(4) int Out_LQueue(LQuere *q, datatype *x):弹出链队q的第一个元素x，若成功则返回返回1否则返回0。

[函数]

LQueae *Init_LQueue()

{ LQueue *q, *p;

q=malloc(sizeof(LQueue)); /*申请链队指针*/

P=malloc(sized(QNode));/*申请头尾指针结点*/

p-＞next=NULL;

(1)=p;

return q;

}

int Empty_LQueue(LQueue *q)

{ if(q-＞front (2) q＞rear) return 0;

else return 1;

}

void In_LQueue(LQueue *q, datatype x)

{ QNoda *p;

p=malloc(sizeof(QNnode));/*申请新接点*/

p-＞data=x;

p-＞next=NULL;

(3)=p;

q-＞rear=p;

}

int Out_LQueue(LQueue *q, datatype *x)

{ QNnode *p;

if(Empty_LQueue(q)) return 0; /*队空,操作失败*/

else{

p=q-＞front-＞next;

*x=(4);

(5)=p-＞next;

free(p);

if (q-＞front-＞next= =NULL)q-＞rear=q-＞front;

return 1;

}

}

阅读下列函数说明和C函数，将应填入(n)处的字句写在对应栏内。

[函数2.1说明]

Fibonacci数列中头两个数均为1，从第三个数开始，每个数等于前两个数之和。下述程序计算Fibonacci数列中前15个数，并以每行5个数的格式输出。

[函数2.1]

include ＜stdio.h＞

main()

{ int i,f,f1=1,f2=1;

printf("%5d%5d",f1,f2);

for(i=3;i＜=15;i++){

f=(1);

printf("%5d",f);

if((2)= =0) printf("\n");

f1=12;

(3);

}

}

[函数2.2说明]

函数fun(char *str1,char *str2)的功能是将字符串str2拼接到str1之后。

[函数2.2]

fun(char *str1,char *str2)

{ int i,j;

for(i=0;str1[i]!='\0';i++);

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

(5);

}

下而程序实现十进制向其他进制的转换。

[C++程序]

include"ioStream．h"

include"math．h"

include ＜conio．h＞

typedef struct node{

int data；

node *next；

}Node；

class Transform

{

public：

void Trans(int d，int i)； //d为数字；i为进制

void print();

private：

Node *top；

}；

void Transform.:Trans(int d,int i)

{

int m，n=0；

Node *P；

while(d＞0)

{

(1) ;

d=d/i；

p=new Node；

if(!n){

P-＞data=m；

(2) j

(3) ;

n++;

}

else{

p-＞data=m；

(4) ；

(5) ；

}

}

}

void Transform.:print()

{

Node *P;

while(top!=NULL)

{

p=top；

if(P-＞data＞9)

cout＜＜data+55：

else

cout＜＜data；

top=p-＞next；

delete P;

}

}

阅读以下函数说明和C语言函数，将应填入(n)处的字句写在对应栏内。

[说明]

这是一个模拟渡口管理的算法。某汽车轮渡口，过江渡船每次能载10辆车过江。过江车辆分为客车类和火车类，上船有如下规定：同类车先到先上船，客车先于货车上渡船，且每上4辆客车，才允许上一辆货车；若等待客车不足4辆，则以货车代替，若无货车等待则允许客车都上船。

程序中用到的函数有enqueue(queue*sq，elemtype*x)在队列sq中入队一个元素x；outqueue(queue*sq，elemtype*x)在队列sq中出队一个元素，并将其值赋给x；empty(queue*sq)判断队列sq是否为空队，若为空，返回1；否则返回0。

[C程序]

include＜stdio.h＞

void pass(){

queue bus,truct; /*bus表示客车队列，truck表示货车队列*/

char ch;

int n,tag； /* ]n为车号，tag为标志，tag=0表示客车，tag=1表示货车*/

intcount=0，countbus=0，counttruck=0; /*分别表示上渡船汽车数、客车数、货车数*/

while(1){

printf("输入命令: \n");

Scanf("%c"，&ch);

switch(ch){

case'e':

case'E': printf("车号: \n");

Scanf("%d"，&n);

printf("客车\货车(0\1): \n");

scanf("%d"，&tag);

if( (1) )

enqueue(&bus,n);

else

enqueue(&truck,n);

break;

case'i':

case'I': while(count＜10){

if( (2) && empty(&bus)==0){ /*客车出队*/

outqueue(&bus,&n);

printf("上船的车号为: \n");

count++;

(3) ;

}

eise if( (4) ){ /*货车出队*/

countbus=0;

outqueue(&truck,&n);

printf("上船的车号为: \n");

count++;

counttruck++;

}

else if(empty(&bus)==0){

(5);

outqueue(&truck,&n);

printf("没有10辆车排队轮渡\n");

count++;

countbus++;

}

else{

printf("没有10辆车排队轮渡\n");

retUrn;

}

break;

}

case'q':

case'Q':break;

}

if(ch=='q' || ch=='Q')

break;

}

}

阅读以下说明和C语言函数，将应填入(n)处的字句写在对应栏内。

【说明】

输入数组，最大的与第一个元素交换，最小的与最后一个元素交换，输出数组。

【函数】

main ( )

{

int number[10];

input (number);

max min (number);

output (number);

}

input (number)

int number[10];

{int i;

for ( i=0;i＜9;i++ )

scanf ( "%d,",&number[i] );

scanf ( "%d",&number[9] );

}

max_min ( array )

int array[10];

{int *max,*min,k,1;

int *p,*arr_end;

arr end=(1);

max=min=array;

for ( p=(2);p＜arr_end;p++ )

if((3)) max=p;

else if ( *p＜*min ) min=p;

(4);

l=*min;

(5);array[0]=1;1=*p;

*p=array[9];array[9]=k;k=*p;

return;

}

output ( array )

int array[10];

{ int *p;

for ( p=array;p＜array+9;p++ )

printf ( "%d,",*p );

printf ( "%d\n",array[9] );

}

阅读以下说明和C语言函数，将应填入(n)处的字句写在对应栏内。

【说明】

下面的程序构造一棵以二叉链表为存储结构的二叉树算法。

【函数】

BTCHINALR *createbt ( BTCHINALR *bt )

{

BTCHINALR *q;

struct node1 *s [30];

int j,i;

char x;

printf ( "i,x =" ); scanf ( "%d,%c",&i,&x );

while (i!=0 && x!='$')

{ q = ( BTCHINALR* malloc ( sizeof ( BTCHINALR )); //生成一个结点

(1);

q-＞1child = NULL;

q-＞rchild = NULL;

(2);

if((3);)

{j=i/2 //j为i的双亲结点

if(i%2==0

(4) //i为j的左孩子

else

(5) //i为j的右孩子

}

printf ( "i,x =" ); scanf ( "%d,%c",&i,&x ); }

return s[1]

}

)应修改为(4)。

阅读以下技术说明、流程图和C程序，根据要求回答问题1和问题2。

【说明】

如图6-13所示的程序流程图描述了对8位二进制整数求补的算法。该算法的计算过程如下：从二进制数的低位(最右位)开始，依次向高位逐位查看，直到首次遇到“1”时，停止查看。然后，对该“1”位左面的更高位(如果存在的话)，逐位求反，所得的结果就是对原二进制数求补的结果。例如：对二进制整数10010110求补的结果时01101010。

设8位二进制整数中的各位，从低位到高位，依次存放在整型数组BIT的BIT[1]～BIT[8]中。例如，二进制整数10010110存放在数组BIT后，则有BIT[1]=0，BIT[2]=1，…，BIT[7]=0，BIT[8]=1。若流程图中存在空操作，则用NOP表示。

以下待修改的【C程序】完成的功能是：对于给定的1个长正整数，从其个位数开始，每隔一位取1个数字(即取其个位、百位和万位等数字)，形成1个新的整数并输出。例如，将该程序修改正确后，运行时若输入“9753186420”，则输出的整数为“73840”。

【C程序】

行号 C代码

01 include ＜stdio.h＞

02 int main()

03 { long n,num;

04 int i;

05 do {

06 printf("请输入一个正整数:");

07 scanf("%1d",n);

08 }while(n＜=0);

09 k = 1;

10 for (i=1;n＞=0;i++) {

11 if (i%2=1) {

12 num = num + (n%10)*k;

13 k = k*10;

14 }

15 n = n/10;

16 }

17 printf("新数据为：%d\n",num);

18 return 0;

19 }

请将图6-13流程图中(1)～(5)空缺处的内容补充完整。其中，(1)空缺处按“循环变量名：循环初值，增量，循环终值”格式描述。

阅读以下说明和C程序代码，将程序补充完整。

[说明]

下面C程序代码的功能是：对于输入的一个正整数n(100≤n＜1000)，先判断其是否是回文数(正读反读都一样的数)。若不是，则将n与其反序数相加，再判断得到的和数是否为回文数，若还不是，再将该和数与其反序数相加并进行判断，依此类推，直到得到一个回文数为止。例如，278不是回文数，其反序数为872，相加后得到的1150还不是回文数，再将1150与其反序数511相加，得到的1661是回文数。

函数int isPalm(long m)的功能是：将正整数m的各位数字取出存入数组中，然后判断其是否为回文数。若m是回文数则返回1，否则返回0。

[C程序代码]

include＜stdio.h＞

include＜stdlib.h＞

int isPalm(long m)

{

int i=0, k=0;

char str[32];

while(m＞0) {

str[k++]= _______ +'0';

m=m/10;

}

for(i=0; i＜k/2; i++)

if(str[i]!=str _______ )return 0;

return 1;

}

int main( )

{

long n, a, t;

printf("input a positive integer: "); scanf("%ld", &n);

if(n＜100||n＞=1000)return -1;

while( _______ ) {

printf("%id-＞", n);

for(a=0, t=n; t＞0; ){

a= _______ *10+t%10; t=t/10;

n= _______ ;

printf("%id\n", n);

system("pause"); return 0;