耿国华数据结构第六章答案.docx
《耿国华数据结构第六章答案.docx》由会员分享，可在线阅读，更多相关《耿国华数据结构第六章答案.docx（20页珍藏版）》请在冰豆网上搜索。
耿国华数据结构第六章答案
总结二叉树
1、深度为k的二叉树的结点个数最多为
。
在此层中最多有
个节点。
2、N各节点的完全二叉树深度为[log（n）]-1.
二、叉树的链式存储结构
Typedefstructnode
{
Inte;
Structnode*lchild;
Structnode*rchild;
}node,*bitree;
先序遍历
Voidpre_order（bitreep）
{
If（p!
=null）
{
Visit（p）
pre_order（p->left）;
pre_order（p->right）;
}
}
三、统计叶子节点的数目
Intn;//作为外部变量统计叶子节点的数目
Voidleaf_num（bitreebt）
{
If（bt!
=null）
{
If（（bt->left==null）&&（bt->right==null））
N++;
Leaf_num（bt->left）;
Leaf_num（bt->right）;
}
}
Intleaf_num（bitreebt）
{
Intn;
If（bt==null）
N==0;
Elseif（（bt->left==null）&&（bt->right==null））
N==1;
Else
{
N=leaf_num（bt->left）+leaf（bt->right）;
}
Returnn;
}
四、求二叉树的高度
Intheight（bitreebt）
{
Intheight,m,n;
If（bt==null）
{
Height=0;
}
Else
{
m=height（bt->leftchild）+1;
n=height（bt->rightchild）+1;
if（m>n）
height=m;
else
height=n;
}
Returnheight;
}
五、中序与后序的非递归算法
Voidinorder（bitreebt）
{
Inte;
Sqstacks;
Initstack（&s）;
Bitnodep;
P=s;
While（（!
emptystack（s））||（p））
{
While（p）
{
Push（&s,p）;
P=p->leftchild;
}
If（!
emptystack（s））
{
pop（&s,&p）;
Visit（p->data）;
P=p->rightchild;
}
}
后续非递归：
Voidlast_order（bitreebt）
{
Bitnode*p,*q;
Bitrees[stack_size];
P=bt;
Q=null;
While（（p）||（!
emptystack（s）））
{
While（p）
{
Push（&s,p）;
P=p->leftchild;
}
If（!
emptystack（s））
{
gethead（s,&p）;
If（（p->rightchild==null）&&（p->rightchild==q））
{
Pop（&s,&p）;
Visit（p）;
Q=p;
P=null;
}
Else
P=p->rightchild
}
}
}
六、线索二叉树
中序线索二叉树找前驱
bitnode*find_pre（bitnode*p）
{
Bitnode*q;
If（p->lefttag==1）
Returnp->leftchild;
Else
{
q=p->leftchild;
While（p->righttag==0）
{
Q=p;
P=p->rightchild;
}
Returnq;
}
}
Bitnode*find_last（bitnode*p）
{
Bitnode*q,*pre;
Q=p;
If（q->righttag==1）
Returnq->rightchild;
Else
{
Q=q->rightchild
While（q->righttag==0）
{
Pre=q;
Q=q->rightchild;
}
Returnq->rightchild;
}
}
七、二叉树相似性的判断
#defineok1
Inttre_alike（bitreeb,bitreea）
{
Intm,n;
Bitnode*p,*q;
P=a;
Q=b;
If（（a==null）&&（b==null））
{
Returnok;
}
Elseif（（（a!
=null）&&（b==null））||（（a==null）&&（b!
=null）））
{
Reuturnnull;
}
Else
{
M=tre_alike（b->left,a->left）;
N=tre_alike（b->left,a->left）;
Returnm*n;
}
}
求根节点到r之间的路径
voidpath（bitreebt,bitnide*r）
{
Bitnode*p,*q;
Inttop=0,I,flag=0;
Bitrees[stacksize];
P=bt;
Q=null;
While（（p!
=null）||（top>=0））
{
While（p!
=null）
{
top++;
S[top]=p;
If（top>max）
{
Flag=-1;
Break;
}
P=p->leftchild;
}
If（top>0）
{
P=S[top];
If（（p->right==null）||（p->rightchild==q））
{
If（p==r）
{
For（i=1;i<=top;I++）
Print（“%d”,p->data）;
Top=0;
}
Else{
Q=p;
P=null;
Top--;
}
}
Else
{
P=p->rightchild;
}
}
}
}
层次遍历二叉树
Voidlevel_order（bitreebt）
{
Bitnode*p;
Queen*q;
Init（q）;
If（bt==null）
Return;
Else
{
P=bt;
Enqueue（q,p）;
While（!
isempty（q））
{
dequeue（q,p）;
visit（p）;
if（p->leftchild!
=null）
Enqueue（q,p->left）;
If（p->rightchild!
=null）
Enqueue（q,p->right）;
}
}
}
习题
12、
Voidfind（bitreeL,intI,intj）
{
Intm,n;
While（（i!
=j）&&（i>0）&&（j>0））
{
If（i>j）
{i=i/2;}
Else
{
J=j/2;
}
If（i==j）
ReturnL[i]->data;
Else
ReturnL[0]->data;
}
}
13、
intfound=FALSE;
Bitree*Find_Near_Ancient（BitreeT,Bitreep,Bitreeq）//求二叉树T中结点p和q的最近共同祖先
{
Bitreepathp[100],pathq[100]//设立两个辅助数组暂存从根到p,q的路径
Findpath（T,p,pathp,0）;
found=FALSE;
Findpath（T,q,pathq,0）;//求从根到p,q的路径放在pathp和pathq中
for（i=0;pathp[i]==pathq[i]&&pathp[i];i++）;//查找两条路径上最后一个相同结点
returnpathp[--i];
}//Find_Near_Ancient
voidFindpath（BitreeT,Bitreep,Bitreepath[],inti）//求从T到p路径的递归算法
{
if（T==p）
{
found=TRUE;
return;//找到
}
path[i]=T;//当前结点存入路径
if（T->lchild）Findpath（T->lchild,p,path,i+1）;//在左子树中继续寻找
if（T->rchild&&!
found）Findpath（T->rchild,p,path,i+1）;//在右子树中继续寻找
if（!
found）path[i]=NULL;//回溯
}//Findpath
14、两种方法
（1）、
Intn=0;
voidleaf_num（bitreebt）
{
If（bt!
=null）
{
If（（bt->leftchild==null）&&（bt->rightchild==null））
{
N++
}
Else
{
leaf_num（bt->leftchild）;
leaf_num（bt->rightchild）;
}
}
}
2、
Intleaf_num（bitreebt）
{
IntI;
If（bt==null）
I=0;
Elseif（（bt->leftchild==null）&&（bt->rightchild==null））
{
I=1;
}
Else
{
I=leaf_num（bt->left）+leaf_num（bt->right）;
}
ReturnI;
}
15、
intDel-subtree（Bitreebt）{
//删除bt所指二叉树，并释放相应的空间
if（bt）{
Del-subtree（bt->lchild）;
Del-subtree（bt->rchild）;
free（bt）;
}
returnOK;
}//Del-subtree
StatusSearch-del（Bitreebt,TelemTypex）{
//在bt所指的二叉树中，查找所有元素值为x的结点，并删除以它为根的子树
if（bt）{
if（bt->data==x）Del-subtree（bt）;
else{
Search-Del（bt->lchild,x）;
Search-Del（bt->rchild,x）;
}
}
returnOK;
}//Search-Del
16、
BitreePreOrder_Next（Bitreep）//在先序后继线索二叉树中查找结点p的先序后继,并返回指针
{
if（p->lchild）returnp->lchild;
elsereturnp->rchild;
}//PreOrder_Next
分析:
总觉得不会这么简单.是不是哪儿理解错了?
6.57
BitreePostOrder_Next（Bitreep）//在后序后继线索二叉树中查找结点p的后序后继,并返回指针
{
if（p->rtag）returnp->rchild;//p有后继线索
elseif（!
p->parent）returnNULL;//p是根结点
elseif（p==p->parent->rchild）returnp->parent;//p是右孩子
elseif（p==p->parent->lchild&&p->parent->tag）
returnp->parent;//p是左孩子且双亲没有右孩子
else//p是左孩子且双亲有右孩子
{
q=p->parent->rchild;
while（!
q->ltag||!
q->rtag）
{
if（!
q->ltag）q=q->lchild;
elseq=q->rchild;
}//从p的双亲的右孩子向下走到底
returnq;
}//else
先序后继：
Bitnode*find_pre（bitnode*P）
{
If（p->lefttag==0）
{
Returnp->leftchild;
}
Else
{
Returnp->rightchildl
}
}
后继前驱：
Void*find_last（bitnode*q）
{
If（p->righttag==0）
{
Returnp->leftchild;
}
Else
{
Returnp->rightchildl
}
}
19、
intGetDepth_CSTree（CSTreeT）//求孩子兄弟链表表示的树T的深度
{
if（!
T）return0;//空树
else
{
for（maxd=0,p=T->firstchild;p;p=p->nextsib）
if（（d=GetDepth_CSTree（p））>maxd）maxd=d;//子树的最大深度
returnmaxd+1;
}
}//GetDepth_CSTree
intLeafCount_CSTree（CSTreeT）//求孩子兄弟链表表示的树T的叶子数目
{
if（!
T->firstchild）return1;//叶子结点
else
{
count=0;
for（child=T->firstchild;child;child=child->nextsib）
count+=LeafCount_CSTree（child）;
returncount;//各子树的叶子数之和
}
}//LeafCount_CSTree
intGetDegree_CSTree（CSTreeT）//求孩子兄弟链表表示的树T的度
{
if（!
T->firstchild）return0;//空树
else
{
degree=0;
for（p=T->firstchild;p;p=p->nextsib）degree++;//本结点的度
for（p=T->firstchild;p;p=p->nextsib）
{
d=GetDegree_CSTree（p）;
if（d>degree）degree=d;//孩子结点的度的最大值
}
returndegree;
}//else
}//GetDegree_CSTree
20、
Voidlast_order（bitreebt）
{
Bitreea[max];
Bitnode*p,*q;
P=bt;
Q=null;
Inttop=0;
While（（top>0）||（p!
=null））
{
While（p!
=null）
{
Top++;
Overflow（）;
A[top]=p;
P=p->left
If（top>0）
{
P=a[top];
If（（p->righchild==null）||（p->right==q））
{
Visit（p）;
Q=p;
P=null;
Top--;
}
Else
P=p->right;
}
}
}
}
21、
Intzheze（intflag,bitreebt）
{
If（flag!
=0）
{
If（bt==null）;
Elseif（（（bt->leftchild==null）&&（bt->rightchild!
=null））||（（（bt->leftchild!
=null）&&（bt->rightchild==null）））
Flag=1;
Else
{
Flag=zheze（flag,bt->left）+zheze（flag,bt->right）
}
}
Returnflag;
}
22、
intn[M];//向量存放各层结点数
inti=1;
intmax=0;//最大宽度
#defineM10//假设二叉树最多的层数
intWidth（BinTreeT）
{
if（T）
{
if（i==1）//若是访问根结点
{
n[i]++;//第1层加1
i++;//到第2层
if（T->lchild）//若有左孩子则该层加1
n[i]++;
if（T->rchild）//若有右孩子则该层加1
n[i]++;
}
else
{//访问子树结点
i++;//下一层结点数
if（T->lchild）
n[i]++;
if（T->rchild）
n[i]++;
}
if（maxWidth（T->lchild）;//遍历左子树
i--;//往上退一层
Width（T->rchild）;//遍历右子树
}
returnmax;
}//算法结束
希望可以给你帮助！
23、先序的非递归算法
Voidpre_order（bitreebt）
{
Bitnode*p;
Inttop=0,i=0;
P=bt;
Bitrees[max];
While（top>0||p!
=null）
{
While（p!
=null）
{
top++;
If（t>=mpax）
Return;
A[top]=p;
P=p->left;
}
If（top>0）
{
P=S[top--];
Visit（p）;
If（p->right）
P=p->right;
}
}
}
26、交换左右子树
Voidchange（bitreebt）
{
If（bt!
=null）
{
Bitnode*p,*q;
P=bi->left;
Q=bi->right;
Bi->right=p;
Bi->left=q;
change（p）;
change（q）;
}
}
27、遍历前序线索树
Bitnode*first（bitreebt）
{
If（bt!
=null）
Returnbt;
Else
Returnnull;
}
Bitnnode*next（bitnode*p）
{
If（p->lefttag==0）
Returnp->leftchild;
Else
Returnp->rightchild;
}
Voidvisit_all（bitreebt）
{
Bitnode*p;
P=first（bt）;
While（p）
{
Visit（p）;
P=next（p）;
}
}
28、遍历顺序完全二叉树
Voidpre_order（inta[],intn,inti）//初始i=0
{
If（i{
Visita[i]
pre_order（a,n,2i）;
pre_order（a,n,2i+1）;
}
}
升级会员 