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

[函数2.1说明]

函数strcpy的功能是将字符串str2的内容复制到字符申str1。

[函数2.1]

(1) strcpy (char *slr1, const char *str2)

{ char * temp;

while( * str2!='\0') *cp++ =(2);

(3)='\0';

return str1;

}

[函数2.2说明]

函数int strcmp(const char *str1, const char *str2)的功能是按字典序比较两个字符串str1和str2的大小。当str1＜str2时返回-1，当str1＞str2时返回1，否则返回0。

[函数2.2]

int strcmp(const char *str1, const char *str2)

{ while( *str1= =* str2) {

if(* s1= =(4)) return 0;

s1++;

(5);

}

if( *str1＜*str2) return -1;

return 1;

}

[函数2.1说明]

下面程序的功能是：将由键盘输入的某个十进制数转换成对应的R进制数并输出。这里R是 2到16的整数，由键盘输入。例如，输入n=128，base=13后的输出为9B。

[函数2.1]

include ＜stdio.h＞

main()

{ char b[16]={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};

int c[64],n,i=0,base;

printf("Enter a number:");scaaf("%d",&n);

printf("Enter new base:");scanf("%d",&base);

do{c[i]=(1);

i++;

n=n/base;

}while((2));

printf("Transmit new base:");

for(- -i;i＞=0;- -i)printf("%c",(3));

}

[函数2.2说明]

所谓回文字符中是指正序和逆序拼写相同的字符串，例如astrtsa，adgdtdgda等。下面函数int fun(char *str)的功能是判断字符串str是否是回文，当字符串是回文时，函数返回1，否则返回0。

[函数2.2]

int fun(char *str)

{ int i,j,l;

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

l=i/2;

for(j=0,i- -;j＜=1;(4))

if((5)) return 0;

return 1;

}

【函数2.1说明】

函数palindrome(char s[])的功能是，判断字符串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”，调用此函数后，将输出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);

}

}

[函数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);

}

[说明]

循环队列的类型定义如下(其中队列元素的数据类型为datatype)：

typedef struct{

datatype data[MAXSIZE]; /*数据的存储区*/

int front,rear; /*队首、队尾指针*/

int num; /*队列中元素的个数*/

}c _ SeQueue; /*循环队*/

下面函数及其功能说明如下：

(1) c_SeQueue* Init_SeQueue()：新建队列；

(2) int ln_SeQueue( c_SeQueue *q, datatype x)：将元素x插入队列q，若成功返回1否则返回0；

(3) int Out_SeQueue (c_SeQueue *q, datatype *x)：取出队列q队首位置的元素，若成功返回1否则返回0。

[函数]

c_SeQueue* Init_SeQueue()

{ q=malloc(sizeof(c_SeQueue));

q-＞front=q-＞rear=MAXSIZE-1;

(1);

return q;

}

int In_SeQueue( c_SeQueue *q, datatype x)

{ if(q-＞num= =MAXSIZE) return 0; /*队满不能入队*/

else {

q-＞rear=(2);

q-＞data[q-＞rear]=x;

(3);

return 1; /*入队完成*/

}

}

int Out_SeQueue( c_SeQueue *q, datatype *x)

{ if (q-＞num= =0) return 0; /*队空不能出队*/

else{

*x=(4); /*读出队首元素*/

q-＞front=(5);

q-＞num- -;

return 1; /*出队完成*/

}

}

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

【函数2．1说明】

函数palindrome(char s［］)的功能是，判断字符串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"，调用此函数后，将输出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) ；

}

}

[说明]

用链式存储结构实现的栈称为链栈。若链栈元素的数据类型为datatype，以LinkStack记链栈结构，其类型定义为：

typedef struct node

{ datatype data；

stmct node * next;

} StackNode, * LinkStack;

由于栈的主要操作都是在栈顶进行的，因此我们把链表的头部作为栈顶。设top为栈顶指针，即：LinkStack top。

下面各函数的功能说明如下：

(1)LinkStack Init_LinkStack()：建立并返回空的链栈；

(2)int Empty_LinkStack(LinkStack top)：判断top所指链栈是否空；

(3)LinkStack Push_LinkStack(LinkStacktop，datatypex)：将数据x压人top所指链栈的栈顶，返回新栈指针；

(4)LinkStack Pop_LinkStack (LinkStacktop, datatype*x)：弹出top所指链栈的栈顶元素x，返回新栈指针。

[函数]

LinkStaek Init_LinkStack( )

{ returnNULL;

int Empty_LinkStack ( LinkStaek top)

if(top = = NULL) return 1;

else return 0;

LinkStaek Push_LinkStaek( LinkStaektop, datatype X)

{ StaekNode *s;

s=malloc (sizeof(StaekNode) );

(1)= x;

(2)= top;

(3);

return top;

}

LinkStaek Pop_LinkStack (LinkStacktop, datatype * x)

{ StaekNode *p;

if(top = = NULL) return NULL;

else{

* x =(4);

p = top;

(5);

free (p);

return top;

}

}

【说明】

所谓货郎担问题，是指给定一个无向图，并已知各边的权，在这样的图中，要找一个闭合回路，使回路经过图中的每一个点，而且回路各边的权之和最小。

应用贪婪法求解该问题。程序先计算由各点构成的所有边的长度(作为边的权值)，按长度大小对各边进行排序后，按贪婪准则从排序后的各边中选择边组成回路的边，贪婪准则使得边的选择按各边长度从小到大选择。

函数中使用的预定义符号如下：

define M 100

typedef struct{/*x为两端点p1、p2之间的距离，p1、p2所组成边的长度*/

float x;

int p1, p2;

}tdr;

typedef struct{/*p1、p2为和端点相联系的两个端点，n为端点的度*/

int n, P1, p2;

}tr;

typedef struct{/*给出两点坐标*/

float x,y;

}tpd;

typedef int tl[M];

int n=10;

【函数】

float distance(tpd a,tpd b);/*计算端点a、b之间的距离*/

void sortArr(tdr a[M], int m);

/*将已经计算好的距离关系表按距离大小从小到大排序形成排序表，m为边的条数*/

int isCircuit(tr[M], int i, int j);

/*判断边(i, j)选入端点关系表r[M]后，是否形成回路，若形成回路返回0*/

void selected(tr r[M], int i, int j);/*边(i,j)选入端点关系表r*/

void course(tr r[M], tl 1[M]);/*从端点关系表r中得出回路轨迹表*/

void exchange(tdr a[M], int m, int b);

/*调整表排序表，b表示是否可调，即是否有边长度相同的边存在*/

void travling(tpd pd[M], int n, float dist, t1 locus[M])

/*dist记录总路程*/

{

tdr dr[M];/*距离关系表*/

tr r[M];;/*端点关系表*/

int i, j, k, h, m;/*h表示选入端点关系表中的边数*/

int b;/*标识是否有长度相等的边*/

k=0;

/*计算距离关系表中各边的长度*/

for(i=1;i＜n;i++){

for(j=i+1;j＜=n;j++){

k++;

dr[k].x=(1);

dr[k].p1=i;

dr[k].p2=j;

}

}

m=k;

sortArr(dr,m);/*按距离大小从小到大排序形成排序表*/

do{

b=1;

dist=0;

k=h=0;

do{

k++;

i=dr[k].p1;

j=dr[k].p2;

if((r[i].n＜=1)&&(r[j].n＜=1)){/*度数不能大于2*/

if((2)){

/*若边(i，j)加入r后形成回路，则不能加入*/

(3);

h++;

dist+=dr[k].x;

}else if((4)){

/*最后一边选入r成回路，则该边必须加入且得到解*/

selected(r,i,j);

h++;

&n

【说明】

函数DeleteNode(Bitree*r，inte)的功能是：在树根节点指针为r的二叉查找(排序)树上删除键值为e的节点，若删除成功，则函数返回0，否则函数返回-1。二叉查找树节点的类型定义为：

typedef struct Tnode{

int data;/*节点的键值*/

struct Tnode *Lchild,*Rchiid;/*指向左、右子树的指针*/

}*Bitree;

在二叉查找树上删除一个节点时，要考虑3种情况。

①若待删除的节点p是叶子节点，则直接删除该节点。

②若待删除的节点p只有一个子节点，则将这个子节点与待删除节点的父节点直接连接，然后删除节点。

③若待删除的节点p有两个子节点，则在其左子树上，用中序遍历寻找关键值最大的节点 s，用节点s的值代替节点p的值，然后删除节点s，节点s必属于上述①、②情况之一。

【函数5-5】

int DeleteNode(Bitree *r,int e){

Bitree p=*r,pp,s,c;

while( (1) {/*从树根节点出发查找键值为e的节点*/

pp=p;

if(e＜p-＞data)p=p-＞Lchild;

else p=p-＞Rehild;

}

if(!p)retrn -1;/*查找失败*/

if(p-＞Lchild && p-＞Rchild){/*处理情况③*/

s=(2); pp=p;

while( (3)){pp=s;s=s-＞Rchild;}

p-＞data=s-＞data;p=s;

}

/* 处理情况①、②*/

if((4))c=p-＞Lchild;

else c=p-＞Rchild;

if(p== *r)*r=c;

else if((5))pp-＞Lchild=c;

else pp-＞Rchild=c;

free(p);

return 0;

}

[说明]

Kruskal算法是一种构造图的最小生成树的方法。设G为一无向连通图，令T是由G的顶点构成的于图，Kmskal算法的基本思想是为T添加适当的边使之成为最小生成树：初始时，T中的点互相不连通；考察G的边集E中的每条边，若它的两个顶点在T中不连通，则将此边添加到T中，同时合并其两顶点所在的连通分量，如此下去，当添加了n-1条边时，T的连通分量个数为1，T便是G的一棵最小生成树。

下面的函数void Kruskal(EdgeType edges[],int n)利用Kruskal算法，构造了有n个顶点的图 edges的最小生成树。其中数组father[]用于记录T中顶点的连通性质：其初值为father[i]=-1 (i=0,1,…,n-1)，表示各个顶点在不同的连通分量上；若有father[i]=j，j＞-1，则顶点i，j连通；函数int Find(int father[],int v)用于返回顶点v所在树形连通分支的根结点。

[函数]

define MAXEDGE 1000

typedef struct

{ int v1;

int v2;

}EdgeType;

void Kruskal(EdgeType edges[],int n)

{ int father[MAXEDGE];

int i,j,vf1,vt2;

for(i=0;i＜n;i+ +) father[i]=-1;

i=0;

j=0;

while(i＜MAXEDGE && j＜(1))

{ vf1=Find(father,edges[i].v1);

vf2=Find(father,edges[i].v2);

if((2))

{(3)=vf1;

(4);

printf("%3d%3d\n",edges[i].v1,edges[i].v2);

}

(5);

}

}

int Find(int father[],int v)

{ int t;

t=v;

while(father[t]＞=0) t=father[t];

return(t);

}