下列算法的功能是：统计二叉树中叶子结点的个数，二叉树以二叉链表存储，请填空。 typedef struct BiTNode{ TElemType data; struct BiTNode *lchild； struct BiTNode *rchild; }BiTNode,*BiTree; int CountLeaves（BiTree BT,int count) { if（（1) ) { if（（2) ) count++; （3) ; （4) ; } return （count); }
下列算法的功能是：统计二叉树中叶子结点的个数，二叉树以二叉链表存储，请填空。 typedef struct BiTNode{ TElemType data; struct BiTNode *lchild； struct BiTNode *rchild; }BiTNode,*BiTree; int CountLeaves（BiTree BT,int &count) { if（（1) ) { if（（2) ) count++; （3) ; （4) ; } return （count); }
参考答案和解析
C
相关考题：
函数 main() 的功能是 : 在带头结点的单链表中查找数据域中值最小的结点 . 请填空#include stdio.hstruct node{ int data;struct node *next;};int min(struct node *first)/* 指针 first 为链表头指针 */{ strct node *p; int m;p=first-next; m=p-data;p=p-next;for(;p!=NULL;p= _[20]_______ )if(p-datam) m=p-data;return m;}
设计递归算法,判断二叉树t是否满足小根堆的特点。二叉链表的类型定义如下: typedef int datatype;//结点的数据类型，假设为inttypedef struct NODE *pointer;//结点指针类型struct NODE {datatype data;pointer lchild,rchild;};typedef pointer bitree;//根指针类型
已知一棵二叉树用二叉链表存储，t指向根节点，P指向树中任一节点。下列算法为输出从t到P之问路径上的节点。[C程序]define MaxSize 1000typedef struct node {TelemType data ;struct node *ichiid，*rchiid；}BiNode，*BiTree；void Path(BiTree t，BiNode *P){BiTree *stack[Maxsize]，*stackl[Maxsize],*q；int tag[Maxsize]，top=0，topl；q=t；/*通过先序遍历发现P*/do{while(q!=NULL ＆＆q!=p)/*扫描左孩子，_日．相应的节点不为P*/{ (1) ；stack[top]=q；tag[top]=0；(2) ；}if(top＞0){ if(stack[top]=P) break； /*找到P，栈底到栈顶为t到P*/if(tag[top]==1)top--;else { q=stack[top]；q=q-＞rchiid;tag[top]=1;}}} (3) ；top--；topl=0；while(top＞0) {q=stack[top]； /*反向打印准备*/topl++；(4) ；top--;}while( (5) ){ /*打印栈的内容*/q=stackl[topl]jprintf(q-＞data)；topl--；}}
●试题三阅读下列函数说明和C函数，将应填入(n)处的字句写在答题纸的对应栏内。【函数3说明】函数DeleteNode(Bitree*r,int e)的功能是：在树根结点指针为r的二叉查找(排序)树上删除键值为e的结点，若删除成功，则函数返回0，否则函数返回-1。二叉查找树结点的类型定义为：typedef struct Tnode{int data;/*结点的键值*/struct Tnode*Lchild,*Rchild;/*指向左、右子树的指针*/}*Bitree;在二叉查找树上删除一个结点时，要考虑三种情况：①若待删除的结点p是叶子结点，则直接删除该结点;②若待删除的结点p只有一个子结点，则将这个子结点与待删除结点的父结点直接连接，然后删除结点p;③若待删除的结点p有两个子结点，则在其左子树上，用中序遍历寻找关键值最大的结点s ,用结点s的值代替结点p的值，然后删除结点s，结点s必属于上述①、②情况之一。【函数3】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-＞Rchild;}if(!p)return-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;}
下列语句段中，正确的是( )。A．struct{int x；float y；int a[2]；unsigned b[3]；char name[10]；}；B．struct stu{unsigned a[3]；unsigned b[4]；}x；int*p=x.a；C．struct stu{int a；float x[4]；}y={1,1.0};float data=y.x；D．struct nd{int a,b；unsigned c[2]=5；}；
阅读以下函数说明和C语言函数，将应填入(n)处的字句写在对应栏内。[说明]本程序实现对指定文件内的单词进行计数。其中使用二叉树结构来保存已经读入的不同单词，并对相同单词出现的次数进行计数。此二叉树的左孩子结点的字符串值小于父结点的字符串值，右孩子结点的字符串值大于父结点的字符串值。函数getword(char*filename，char*word)是从指定的文件中得到单词。char*strdup(char*S)是复制S所指向的字符串，并返回复制字符串的地址。[C程序]include ＜stdio.h＞include ＜ctype.h＞include ＜string.h＞define MAXWORD 100struct node {char*word;int count;struct node*left;struct node*right;}struct node*addtree(struct node*P,char*w){ int cond;if(p==NULL){ /*向树中插入结点*/P=(struct node*)malloc(sizeof(struct node));P-＞word=strdup(w);P-＞count=1;(1) ;}elseif((oond=strcmp(w,p-＞word))==0) (2) ;else if(cond＜0)p-＞left=(3);else p-＞right=(4);return p;}main(){ Struct node*root;char word[MAXWORD];root=NULL;filename="example.dat";while(getword(filename,word)!=EOF))root=(5);}
阅读以下说明和C语言函数，将应填入(n)处。[说明]二叉排序树或者是一棵空树，或者是具有如下性质的二叉树：若它的左子树非空，则左子树上所有结点的值均小于根结点的值；若它的右子树非空，则右子树上所有结点的值均大于根结点的值；左、右子树本身就是两棵二义排序树。函数insert_BST(char *str)的功能是：对给定的字符序列按照ASCⅡ码值大小关系创建二叉排序树，并返回指向树根结点的指针。序列中重复出现的字符只建一个结点，并由结点中的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; foot-＞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；}
阅读以下说明和C语言函数，将应填入(n)处的字句写在答题纸的对应栏内。[说明]求树的宽度，所谓宽度是指在二叉树的各层上，具有结点数最多的那一层的结点总数。本算法是按层次遍历二叉树，采用一个队列q，让根结点入队列，若有左右子树，则左右子树根结点入队列，如此反复，直到队列为空。[函数]int Width ( BinTree *T{int front=-1, rear=-1; /*队列初始化*/int flag=0, count=0, p; /*p用于指向树中层的最右边的结点, flag 记录层中结点数的最大值*/if ( T!=Null){rear++;(1);flag=1;p=rear;}while ((2)){front++;T=q [front]];if (T-lchild!=Null ){roar+-+;(3);count++;}if ( T-＞rchild!=Null ){rear++; q[rear]=T-＞rchild;(4);}if (front==p ) // 当前层已遍历完毕{if((5))flag=count;count=0;p=rear, //p 指向下一层最右边的结点}}return ( flag );}
阅读下列C函数和函数说明，将应填入(n)处的字句写在对应栏内。【说明】函数DeleteNode (Bitree *r, int e)的功能是：在树根结点指针为r的二叉查找(排序)树上删除键值为e的结点，若删除成功，则函数返回0，否则函数返回-1。二叉查找树结点的类型定义为：typedef struct Tnode{int data； /*结点的键值*/struct Tnode *Lchild, *Rchild； /*指向左、右子树的指针*/}*Bitree：在二叉查找树上删除一个结点时，要考虑3种情况：①若待删除的结点p是叶子结点，则直接删除该结点；②若待删除的结点p只有一个子结点，则将这个子结点与待删除结点的父结点直接连接，然后删除结点p；③若待删除的结点p有两个子结点，则在其左子树上，用中序遍历寻找关键值最大的结点s，用结点s的值代替结点p的值，然后删除结点s，结点s必属于上述①、②情况之一。【函数】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-＞Rchild；}if(!P) return-1； /*查找失败*/if(p-＞Lchild p-＞Rchild) {/*处理情况③*/s=(2)；pp=pwhile (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；}
阅读下列函数说明和C函数，将应填入(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;}
试题四阅读下列函数说明和C函数，将应填入 （n） 处的字句写在答题纸的对应栏内。[函数说明]函数DeleteNode(Bitree *r,int e)的功能是：在树根结点指针为r的二叉查找（排序）树上删除键值为e的结点，若删除成功，则函数返回0，否则函数返回-1。二叉查找树结点的类型定义为：typedef struct Tnode{int data;struct Tnode *Lchild,*Rchild;}*Bitree;在二叉查找树上删除一个结点时，要考虑三种情况：1若待删除的结点p是叶子结点，则直接删除该结点；2若待删除的结点p只有一个子结点，则将这个子结点与待删除结点的父结点直接连接，然后删除结点p；3若待删除的结点p有两个子结点，则在其左子树上，用中序遍历寻找关键值最大的结点s,用结点s的值代替结点p的值，然后删除结点s,结点s必属于上述1、2情况之一。[函数代码]int DeleteNode(Bitree *r,int e) {Bitreep = *r, pp, s, c;while( (1) ) { /*从树根结点出发查找键值为e的结点*/pp = p;if ( e p-data) p = p - Lchild;else p = p-Rchild;}if(!p) return –1; /* 查找失败 */if(p-Lchild p-Rchild) { /* 处理情况3 */s = (2);pp = p;while ( (3) ) { pp = s; s = s- Rchild; }p-data = s -data; p = s;}/*处理情况1、2*/if( (4) ) c = p - Lchild;elsec = p - Rchild;if(p == *r) *r = c;elseif ( (5) ) pp - Lchild = c;elsepp-Rchild = c;free(p);return 0;}
阅读下列函数说明和C函数，将应填入(n)处。【函数3说明】函数DeleteNode(Bitree * r，int e)的功能是：在树根结点指针为r的二叉查找(排序)树上删除键值为e的结点，若删除成功，则函数返回0，否则函数返回-1。二叉查找树结点的类型定义为：typedef struct Tnode{int data； /*结点的键值*/struct Tnode * Lchild，*Rchild； /*指向左、右子树的指针*/} * Bitree；在二叉查找树上删除一个结点时，要考虑三种情况：①若待删除的结点p是叶子结点，则直接删除该结点；②若待删除的结点p只有一个子结点，则将这个子结点与待删除结点的父结点直接连接，然后删除结点P；③若待删除的结点p有两个子结点，则在其左子树上，用中序遍历寻找关键值最大的结点s，用结点s的值代替结点p的值，然后删除结点s，结点s必属于上述①、②情况之一。【函数3】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-＞Rchild；{if(!p)return-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；}
阅读下列说明和c函数代码，将应填入 (n) 处的字句写在答题纸的对应栏内。【说明】对二叉树进行遍历是二叉树的一个基本运算。遍历是指按某种策略访问二叉树的每个结点，且每个结点仅访问一次的过程。函数InOrder。()借助栈实现二叉树的非递归中序遍历运算。设二叉树采用二叉链表存储，结点类型定义如下：typedef struct BtNode{ElemTypedata； ／*结点的数据域，ElemType的具体定义省略*／struct BtNode*ichiid，*rchild； ／*结点的左、右弦子指针域*／)BtNode，*BTree；在函数InOrder()中，用栈暂存二叉树中各个结点的指针，并将栈表示为不含头结点的单向链表(简称链栈)，其结点类型定义如下：typedef struct StNode{ ／*链栈的结点类型*／BTree elem； ／*栈中的元素是指向二叉链表结点的指针*／struct StNode*link；}S％Node；假设从栈顶到栈底的元素为en、en-1、…、e1，则不含头结点的链栈示意图如图5—5所示。【C函数】int InOrder(BTree root) ／*实现二叉树的非递归中序遍历*／{BTree ptr； ／*ptr用于指向二又树中的结点*／StNode*q； ／*q暂存链栈中新创建或待删除的结点指针+／StNode*stacktop=NULL； ／*初始化空栈的栈顶指针stacktop*／ptr=root； ／*ptr指向二叉树的根结点*／while( (1 ) I I stacktop!=NULL){while(ptr!=NULL){q=(StNode*)malloc(sizeof(StNode))；if(q==NULL)return-1；q-elem=ptr；(2) ；stacktop=q； ／*stacktop指向新的栈顶*／ptr=(3 ) ； ／*进入左子树*／}q=stacktop； (4) ； ／*栈顶元素出栈*／visit(q)； ／*visit是访问结点的函数，其具体定义省略*／ptr= (5) ； ／*进入右子树*／free(q)； ／*释放原栈顶元素的结点空间*／}return 0；}／*InOrder*／
阅读以下说明和C语言函数，将应填入(n)处的字句写在对应栏内。[说明]完成以下中序线索化二叉树的算法。[函数]Typedef int datatype;Typedef struct node {Int ltag, rtag;Datatype data;*lchild,* rchild;}bithptr;bithptr pre;void inthread ( p );{if{inthread ( p-＞lchild );if ( p-＞lchild==unll ) (1);if ( P-＞RCHILD=NULL) p-＞rtag=1;if (2){if (3) pre-＞rchild=p;if ( p-＞1tag==1 )(4);}INTHREAD ( P-＞RCHILD );(5);}}
函数min()的功能是:在带头结点的单链表中查找数据域中值最小的结点。请填空includestruc 函数min()的功能是：在带头结点的单链表中查找数据域中值最小的结点。请填空include ＜stdio.h＞struct node{ int data;struct node *next;};int min(struct node *first)/*指针first为链表头指针*/{ struct node *p; int m;p=first-＞next; re=p-＞data; p=p-＞next;for( ;p!=NULL;p=【 】)if(p-＞data＜m ) re=p-＞data;return m;}
阅读以下函数说明和C语言函数，将应填入(n)处的字句写在对应栏内。[说明]已知一棵二叉树用二叉链表存储，t指向根结点，p指向树中任一结点。下列算法为输出从t到P之间路径上的结点。[C程序]define Maxsize 1000typedef struct node{TelemType data;struct node*1child,*rchild;}BiNode,*BiTree;void Path(BiTree t,BiNode*P){ BiTree*stack[Maxsize],*stackl[Maxsize],*q;int tag[Maxsize],top=0,topl;q=t;/*通过先序遍历发现P*/do(while(q!=NULL q!=p)/*扫描左孩子，且相应的结点不为P*/{ (1);stack[top]=q;tag[top]=0;(2);}if(top＞0){ if(stack[top]==P) break; /*找到P，栈底到栈顶为t到P*/if(tag[top]==1)top--;else{q=stack[top];q=q-＞rchild;tag[top]=1;}}} (3);top--; topl=0;while(top＞0){q=stack[top]; /*反向打印准备*/topl++;(4);top--;}while((5)){ /*打印栈的内容*/q=stackl[topl];printf(q-＞data);topl--;}}
以下程序的功能是建立—个带有头结点的单向链表，链表结点中的数据通过键盘输入，当输入数据为-1时，表示输入结束(链表头结点的data域不放数据，表空的条件是ph-＞next==NULL)，请填空。include＜stdio.h＞struct list { int data；struct list *next；}；struct list * creatlist(){ struct list *p，*q，*ph；int a；ph=(struct list *)malloc(sizeof(struct
阅读以下说明和C语言函数，将应填入(n)处的语句写在对应栏内。【说明】下面的程序构造一棵以二叉链表为存储结构的二叉树。【函数】BitTree *createbt(BitTree *bt){BitTree *q;struct node *s[30];int j,i;char x;printf("i,x=");scant("%d,%c",i,x);while(i!=0 x!='$'){q=(BitTree *}malloc(sizeof(BitTree));//生成一个结点(1);q-＞lchild=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[i];}
阅读下列说明和C程序，将应填入(n)处的字句写在对应栏中。[说明]借助一个栈结构，可实现二叉树的非递归遍历算法。InOrderTraverse数实现中序非递归遍历，遍历过程如下：若不是空树，根节点入栈，进入左子树；若已经是空树，则栈顶元素出栈，访问该元素(根节点)，进入该节点的右子树，继续直到遍历完成。函数中使用的预定义符号如下：typedef struct BiTNode{int data；struct BiTNode *iChiid，*rChiid；} BiTNode，*BiTree；typedef struct SNode{/*链栈的节点类型*/BiTree elem；struct SNode *next；}SNode；[函数]int InOrderTraverse(BiTree root){BiTree P；SNode *q，*stop=NULL；/*不带头节点的单链表作为栈的存储结构*/P=root；while(p !=NULL || stop !=NULL){if( (1) ){ /*不是空树*/q=(SNode*)malloc(sizeof q)；if(q==NULL)return-1；/*根节点指针入栈*/(2)；q-＞elem=P；stop=q；P=(3)； /*进入根的左子树*/}else{q=stop；(4)； /*栈顶元素出栈*/printf("%d|，q-＞elem-＞data)； /*防问根节点*/P=(5)； /*进入根的右子树*/free(q)； /*释放原栈顶元素*/}/*if*/}/*while*/return 0；}/*InOrderTraverse*/(1)
阅读以下说明和C函数，将应填入(n)处的字句写在对应栏内。【说明】已知某二叉树的非叶子结点都有两个孩子结点，现将该二叉树存储在结构数组Ht中。结点结构及数组Ht的定义如下：define MAXLEAFNUM 30struct node{char ch; /*当前结点表示的字符，对于非叶子结点，此域不用*/char *pstr; /*当前结点的编码指针，非叶子结点不用*/int parent; /*当前结点的父结点，为0时表示无父结点*/int lchild,rchild;/*当前结点的左、右孩子结点，为0时表示无对应的孩子结点*/};struct node Ht[2*MAXLEAFNUM]; /*数组元素Ht[0]不用*/该二叉树的n个叶子结点存储在下标为1～n的Ht数组元素中。例如，某二叉树如果其存储结构如下图所示，其中，与叶子结点a对应的数组元素下标为1，a的父结点存储在Ht[5]，表示为Ht[1].parent=5。Ht[7].parent=0表示7号结点是树根，Ht[7].child=3、Ht[7].rchild=6分别表示7号结点的左孩子是3号结点、右孩子是6号结点。如果用0或1分别标识二叉树的左分支和右分支(如上图所示)，从根结点开始到叶子结点为止，按所经过分支的次序将相应标识依次排列，可得到一个0、1序列，称之为对应叶子结点的编码。例如，上图中a，b，c，d的编码分别是100，101，0，11。函数LeafCode(Ht[],n)的功能是：求解存储在Ht中的二叉树中所有叶子结点(n个)的编码，叶子结点存储在Ht[1]～Ht[n]中，求出的编码存储区由对应的数组元素pstr域指示。函数LeafCode从叶子到根逆向求叶子结点的编码。例如，对上图中叶子结点a求编码的过程如下图所示。typedef enum Status {ERROR,OK} Status;【C函数】Status LeafCode(struct node Ht[], int n){int pc, pf; /*pc用于指出树中的结点，pf则指出pc所对应结点的父结点*/int i,start;char tstr[31] = {'\0'}; /*临时存储给定叶子结点的编码，从高下标开始存入*/for(i = 1;(1); i++){ /*对所有叶子结点求编码，i表示叶结点在HT数组中的下标*/start = 29;pc = i; pf = Ht[i].parent;while (pf !=(2)) { /*没有到达树根时，继续求编码*/if ((3).lchild == pc ) /*pc所表示的结点是其父结点的左孩子*/tstr[--start] = '0';elsetstr[--start] = '1';pc =(4); pf = Ht[pf].parent; /*pc和pf分别向根方向回退一层*/}/* end of while */Ht[i].pstr = (char *) malloc(31-start);if (!Ht[i].pstr) return ERROR;strcpy(Ht[i].pstr,(5));}/* end of for */return OK;}/* and of LeafCode */
链表题：一个链表的结点结构struct Node{int data ;Node *next ;};typedef struct Node Node ;(1)已知链表的头结点head,写一个函数把这个链表逆序( Intel)
阅读下列函数说明和C函数，将应填入(n)处的字句写对应栏内。[说明]二叉树的二叉链表存储结构描述如下：typedef struct BiTNode{ datatype data;struct BiTNode *lchild, * rchild; /*左右孩子指针*/}BiTNode,* BiTree;对二叉树进行层次遍历时，可设置一个队列结构，遍历从二叉树的根结点开始，首先将根结点指针入队列，然后从队首取出一个元素，执行下面两个操作：(1) 访问该元素所指结点；(2) 若该元素所指结点的左、右孩子结点非空，则将该元素所指结点的左孩子指针和右孩子指针顺序入队。此过程不断进行，当队列为空时，二叉树的层次遍历结束。下面的函数实现了这一遍历算法，其中Visit(datatype a)函数实现了对结点数据域的访问，数组queue[MAXNODE]用以实现队列的功能，变量front和rear分别表示当前队首元素和队尾元素在数组中的位置。[函数]void LevelOrder(BiTree bt) /*层次遍历二叉树bt*/{ BiTree Queue[MAXNODE];int front,rear;if(bt= =NULL)return;front=-1;rear=0;queue[rear]=(1);while(front (2) ){(3);Visit(queue[front]-＞data); /*访问队首结点的数据域*/if(queue[front]—＞lchild!：NULL){ rear++;queue[rear]=(4);}if(queue[front]-＞rchild! =NULL){ rear++;queue[rear]=(5);}}}
阅读下列函数说明和C函数，将应填入(n)处的字句写在对应栏内。[说明]二叉树的二叉链表存储结构描述如下：lypedef struct BiTNode{ datatype data;street BiTNode *lchiht, *rchild; /*左右孩子指针*/ } BiTNode, *BiTree;下列函数基于上述存储结构，实现了二叉树的几项基本操作：(1) BiTree Creale(elemtype x, BiTree lbt, BiTree rbt)：建立并返回生成一棵以x为根结点的数据域值，以lbt和rbt为左右子树的二叉树；(2) BiTree InsertL(BiTree bt, elemtype x, BiTree parent)：在二叉树bt中结点parent的左子树插入结点数据元素x；(3) BiTree DeleteL(BiTree bt, BiTree parent)：在二叉树bt中删除结点parent的左子树，删除成功时返回根结点指针，否则返回空指针；(4) frceAll(BiTree p)：释放二叉树全体结点空间。[函数]BiTree Create(elemtype x, BiTree lbt, BiTree rbt) { BiTree p;if ((p = (BiTNode *)malloc(sizeof(BiTNode)))= =NULL) return NULL;p-＞data=x;p-＞lchild=lbt;p-＞rchild=rbt;(1);}BiTree InsertL(BiTree bt, elemtype x,BiTree parent){ BiTree p;if (parent= =NULL) return NULL;if ((p=(BiTNode *)malloc(sizeof(BiTNode)))= =NULL) return NULL;p-＞data=x;p-＞lchild= (2);p-＞rchild= (2);if(parent-＞lchild= =NULL) (3);else{p-＞lchild=(4);parent-＞lchild=p;}return bt;}BiTree DeleteL(BiTree bt, BiTree parent){ BiTree p;if (parent= =NULL||parent-＞lchild= =NULL) return NULL;p= parent-＞lchild;parent-＞lchild=NULL;freeAll((5));return bt;
阅读以下说明和C函数，填补代码中的空缺(1)～(6)，将解答填入答题纸的对应栏内。【说明】二叉树的宽度定义为含有结点数最多的那一层上的结点数。函数GetWidth()用于求二叉树的宽度。其思路是根据树的高度设置一个数组counter[]. counter[i]存放第i层上的结点数，并按照层次顺序来遍历二叉树中的结点，在此过程中可获得每个结点的层次值，最后从countler[]中取出最大的元素就是树的宽度。按照层次顺序遍历二叉树的实现方法是借助一个队列，按访问结点的先后顺序来记录结点，离根结点越近的结点越先进入队列，具体处理过程为；先令根结点及其层次号（为1）进入初始为空的队列，然后在队列非空的情况下，取出队头所指示的结点及其层次号，然后将该结点的左子树根结点及层次号八队列（若左子树存在），其次将该结点的右子树根结点及层次号八队列（若右子树存在），然后再取队头，重复该过程直至完成遍历。设二叉树采用二叉链表存储，结点类型定义如下：typedef struct BTNode{TElemType data;struct BTNode *left. *right} BTNode , *BiTree _队列元素的类型定义如下typedef struct {BTNode *ptr;int LevelNumber) QElemType;【C函数】int GetWidth (BiTree root){QUEUE Q;QElemType a, b;int width.height = GetHeight(root);int i, *counter =(lnt*) calloc (helght+l. sizeof (int));if ( 1) return -1; ／*申请空间失败*/If(!root ) return -0; /*空树的宽度为0*／if ( 1) return -1 /*初始化队列失败时返回*／A.ptr=root; a.leveinumber=1;If(!Enqueue(＆Q,a)) return-1; ／*元素入队列操作失败时返回*／while (！isEmpty(Q》{if( (3) )return -1; /*出队列操作失败时返回*／Counter[b．LevelNumber]++；／*对层号为b．LevelNumber的结点计数*/if（bNaNr=＞left）{／*若左子树存在，则左于树根结点及其层次号入队*／aNaNr =bNaNr=＞left;a.LevelNurnber =(4) ；If(!EnQueue (Q,a))return -1;}if( bNaNr=＞right){／*若右子树存在，则右子树根结点及其层次号入队*／a．ptr= bNaNr-＞right;a LevelNumber (5) iIf(!EnQueue (Q,a))return -1}}width= counter[1];For(i=1; iheight+1;i++1) /*求counter[ ]中的最大值*/If(6) width =counter[i];Free(counter);Return width;}
试题三（共15分）阅读以下说明和C函数，填充函数中的空缺，将解答填入答题纸的对应栏内。【说明】函数Insert _key (*root,key)的功能是将键值key插入到*root指向根结点的二叉查找树中（二叉查找树为空时*root为空指针）。若给定的二叉查找树中已经包含键值为key的结点，则不进行插入操作并返回0；否则申请新结点、存入key的值并将新结点加入树中，返回l。提示：二叉查找树又称为二叉排序树，它或者是一棵空树，或者是具有如下性质的二叉树：●若它的左子树非空，则其左子树上所有结点的键值均小于根结点的键值；●若它的右子树非空，则其右子树上所有结点的键值均大于根结点的键值；●左、右子树本身就是二叉查找树。设二叉查找树采用二叉链表存储结构，链表结点类型定义如下：typedef struct BiTnode{int key _value; ／*结点的键值，为非负整数*／struct BiTnode *left,*right; ／*结点的左、右子树指针*／}BiTnode, *BSTree；【C函数】int Insert _key( BSTree *root,int key){BiTnode *father= NULL,*p=*root, *s;while( (1)＆＆key!=p-key_value){／*查找键值为key的结点*／father=p；if（key p-key_value）p= (2) ； ／*进入左子树*／else p= (3) ； ／木进入右子树*／}if (p) return 0； ／*二叉查找树中已存在键值为key的结点，无需再插入*／s= (BiTnode *)malloc( (4) )；／*根据结点类型生成新结点*／if (!s) return -1;s-key_value= key; s-left= NULL; s-right= NULL;if( !father)(5) ； ／*新结点作为二叉查找树的根结点*／else ／*新结点插入二叉查找树的适当位置*／if( key father-key_value)father-left = s;elsefather-right = s;retum 1：}
请写出下列递归算法的功能。 typedef struct node{ datatype data； struct node *link； } *LinkList； int ALGORISM（LinkList list） { if（list==NULL） return 0； else return 1+ALGORISM（list-link）； }
问答题请写出下列递归算法的功能。 typedef struct node{ datatype data； struct node *link； } *LinkList； int ALGORISM（LinkList list） { if（list==NULL） return 0； else return 1+ALGORISM（list-link）； }
问答题设某带头结头的单链表的结点结构说明如下：typedef struct nodel{int data struct nodel*next；}node；试设计一个算法：void copy（node*headl，node*head2），将以head1为头指针的单链表复制到一个不带有头结点且以head2为头指针的单链表中。