数据结构树培训讲学.docx
《数据结构树培训讲学.docx》由会员分享，可在线阅读，更多相关《数据结构树培训讲学.docx（27页珍藏版）》请在冰豆网上搜索。
数据结构树培训讲学
数据结构（树）
数据结构与算法上机作业
第三章树
一、选择题
1、在一棵树中，如果结点A有3个兄弟，B是A的双亲，则B的度为D
A.1B.2C.3D.4
2、深度为h的完全二叉树至少有D个结点，至多有B个结点
A.2hB.2h-1C.2h+1D.2h-1
3、具有n个结点的满二叉树有C个叶结点。
A.n/2B.（n-1）/2C.（n+1）/2D.n/2+1
4、一棵具有25个叶结点的完全二叉树最多有C个结点。
A.48B.49C.50D.51
5、已知二叉树的先根遍历序列是ABCDEF，中根遍历序列是CBAEDF，则后根遍历序列是A。
A.CBEFDAB.FEDCBAC.CBEDFAD.不定
6、具有10个叶结点的二叉树中有B个度为2的结点。
A.8B.9C.10D.11
7、一棵非空二叉树的先序遍历序列与后序遍历序列正好相反，则该二叉树一定满足B。
A.所有非叶结点均无左孩子B.所有非叶结点均无右孩子
C.只有一个叶子结点D.A和B同时成立
8、在线索二叉树中，t所指结点没有左子树的充要条件是D。
A.t->left=NULLB.t->ltag=TRUE
C.t->ltag=TRUE且t->left=NULLD.以上都不对
9、n个结点的线索二叉树上含有的线索数为C。
A.2nB.n-1C.n+1D.n
10、二叉树按照某种顺序线索化后，任一结点都有指向其前驱和后继的线索，这种说法B。
A.正确B.错误C.不确定D.都有可能
11、具有n（n>1）个结点的完全二叉树中，结点i（2i>n）的左孩子结点是D。
A.2iB.2i+1C.2i-1D.不存在
12、具有64个结点的完全二叉树的深度为C。
A.5B.6C.7D.8
13、将一颗有100个结点的完全二叉树从上到下、从左到右一次对结点进行编号，根结点的编号为1，则编号为45的结点的右孩子的编号为D。
A.46B.47C.90D.91
14、在结点数为n的堆中插入一个结点时，复杂度为C。
A.O（n）B.O（n2）C.O（log2n）D.O（logn2）
15、两个二叉树是等价的，则它们满足D。
A.它们都为空B.它们的左右子树都具有相同的结构
C.它们对应的结点包含相同的信息D.A、B和C
16、包含n个元素的堆的高度为C。
（符号「a表示取不小a最小整数）
A.nB.「log2nC.「log2（n+1）D.n+1
17、以下说法错误的是B。
A.存在这样的二叉树，对其采用任何次序的遍历其结点访问序列均相同
B.二叉树是树的特殊情形
C.由树转换成二叉树，其根结点的右子树总是空的
D.在二叉树中只有一棵子树的情形下，也要指出是左子树还是右子树
18、设F是一个森林，B是由F变换得到的二叉树。
若F中有n个非终端结点，则B中没有右孩子的结点有C个。
A.n-1B.nC.n+1D.n+2
19、将一棵树T转换为二叉树B，则T的后根序列是B的B。
A.先根序列B.中根序列C.后根序列D.层次序列
20、将一棵树转换为二叉树后，这颗二叉树的形态是B。
A.唯一的，根结点没有左孩子B.唯一的，根结点没有右孩子
C.有多种，根结点都没有左孩子D.有多种，根结点都没有右孩子
21、设树T的度为4，其中度为1,2,3,4的结点个数分别为4,2,1,1，则T中的叶结点的个数为D。
A.5B.6C.7D.8
22、设森林F中有三棵树，第一、第二、第三棵树的结点个数分别为M1,M2,M3。
与森林F对应的二叉树根结点的右子树上的结点个数为D。
A.M1-1B.M1+M2C.M2D.M2+M3
23、若以二叉树的任一结点出发到根的路径上所经过的结点序列按其关键字有序，则该二叉树是C。
A.二叉排序树B.哈夫曼树C.堆D.线索二叉树
24、用5个权值{3,2,4,5,1}构造的哈夫曼树的带权路径长度是C。
A.32B.33C.34D.15
二、填空题
1、一棵二叉树有67个结点，结点的度是0和2。
问这棵二叉树中度为2的结点有33个。
2、含A,B,C三个结点的不同形态的二叉树有0棵。
3、含有4个度为2的结点和5个叶子结点的完全二叉树，有1个度为1的结点。
4、具有100个结点的完全二叉树的叶子结点数为50。
5、在用左右链表示的具有n个结点的二叉树中，共有2n个指针域，其中n-1个指针域用于指向其左右孩子，剩下的n+1个指针域是空的。
6、如果一颗完全二叉树的任意一个非终结结点的元素都大于等于其左儿子结点和右儿子结点（如果有的话）的元素，则称此完全二叉树为最大堆。
7、堆是一种特殊形式的完全二叉树二叉树，对于最大堆而言，其根结点的元素的值应该是所有结点元素中最大的的。
8、二叉树的复制是指按照一棵已知的二叉树复制一个副本，使两者等价。
复制二叉树最长用的方法是后根遍历递归算法。
9、在定义堆时，通常采用数组方式定义相应的二叉树，这样可以很容易实现其相关操作。
10、在构建选择树时，根据孩子结点的获胜者确定他们双亲结点所得到的选择树称为胜者树。
根据孩子结点的失败者确定他们双亲结点所得到的选择树称为败者树。
11、树的表示方法包括数组、邻接表和左右链。
12、表达式（a+b*（c-d））-e/f的波兰式（前缀式）是-+a*b-cd/ef，逆波兰式（后缀式）是abcd-*+e/f-。
13、设F是由T1、T2、T3三棵树组成的森林，与F对应的二叉树为B。
已知T1,T2,T3的结点数分别为n1,n2和n3，则二叉树B的左子树中有n1-1个结点，二叉树B的右子树中有n2+n3个结点。
14、设二叉树的中根序列为ABCDEFG，后根序列为BDCAFGE。
则该二叉树的先根序列为
EGCBDGF。
该二叉树对应的森林中包含2棵树。
15、先根次序遍历森林等同于按先根遍历对应的二叉树，后根次序遍历森林等同与按中根遍历对应的二叉树。
16、一棵哈夫曼树有19个结点，则其叶子结点的个数为10。
17、设有数据WG={7,19,2,6,32,3,21,10}叶节点权重集合，则所构建哈夫曼树的高是6，带权路径长度WPL为261。
18、设有一份电文中共使用6个字符a,b,c,d,e,f，其中出现频率依次为2，3，4，7，8，19，则字符c的哈夫曼编码是001，电文编码的总长度为96。
20、在有n个结点的哈夫曼树中，叶子结点总数为（n+1）/2，非叶结点的总数为（n-1）/2。
三、试分别画出具有4个结点的二叉树的所有不同形态。
四、已知一棵二叉树的中根序列和后根序列分别是BDCEAHFG和DECBHGFA，请画出此二叉树。
五、已知非空二叉树T，写一个算法，求度为2的结点的个数。
要求：
1、定义二叉树的抽象数据类型和型BTREE，并定义基本操作。
2、编写函数count2（BTREET），返回度为2的节点的个数。
3、在主函数中，构建一个二叉树，并验证所编写的算法。
六、用递归方法写一个算法，求二叉树的叶子结点数intleafnum（BTREET）。
要求：
1、定义二叉树的抽象数据类型和型BTREE，并定义基本操作。
2、编写函数leafnum（BTREET），返回树T的叶子节点的个数。
在主函数中，构建一个二叉树，并验证所编写的算法。
七、画出下图所表示的二叉树的中序线索二叉树和先序线索二叉树。
八、已知二叉树的先根序列是AEFBGCDHIKJ，中根序列是EFAGBCHKIJD，画出此二叉树，并画出后序线索二叉树。
九、在中序线索二叉树中插入一个结点Q作为树中某个结点P的左孩子，试给出相应的算法。
要求：
1、定义中序线索二叉树的型THTREE以及基本操作。
2、定义函数voidLInsert（THTREEP,THTREEQ）;实现题目要求的操作。
在主函数中，利用操作RInsert和LInsert构造一个线索二叉树，并中序输出二叉树的结点的元素，验证结果。
十、假设现在有如下的元素：
7、16、49、82、5、31、6、2、44。
画出将每一个元素插入堆中以后的最大堆。
要求：
利用基本操作Insert的基本原理，先用第一个元素7构成一个二叉树，然后将第二个元素16插入该二叉树中，再将第三个元素49插入堆中，……，直到最后一个元素插入为止。
上述过程要求画图完成。
十一、编写一个函数，在最大堆中查找任意元素，并分析其时间复杂度。
要求：
1、定义最大堆的型HEAP及其基本操作。
2、定义函数intFind（HEAPH,Elementtypee），查找e是否为堆的元素，如果是，返回该元素在堆中的位置，如果不是，返回0。
（提示：
利用最大堆的元素特点进行查找，可降低复杂度）
在主函数中首先构建一个二叉树，然后验证所构造的函数。
十二、给定叶子结点的权值集合{15,3,14,2,6,9,16,17}，构造相应的哈夫曼树，并计算其带权路径长度。
十三、已知n=9和一组等价关系：
1≡5、6≡8、7≡2、9≡8、3≡7、4≡2、9≡3
试应用抽象数据类型MFSET设计一个算法，按输入的等价关系进行等价分类。
十四、画出下图所示的森林经转换后所对应的二叉树，并指出在二叉树中某结点为叶子结点时，所对应的森林中结点应满足的条件。
十五、已知森林F的先根序列为：
ABCDEFGHIJKL，后根序列为：
CBEFDGAJIKLH，试画出森林F。
提示：
先画出森林F所对应的二叉树B，然后再将B转换为森林。
十六、画出表达式（A+B*C/D）*E+F*G所对应的树结构，并写出该表达式的波兰表示式和逆波兰表示式。
十七、利用逆波兰表达式求一个四则混合元算的值。
具体要求：
1、定义二叉树的型BTREE和位置的型position。
2、实现二叉树的基本操作。
3、实现将一个四则混合运算转换成二叉树的函数：
BTREEconvert（char*express），其中参数express为四则混合运算表达式，返回值为生成的树。
4、实现计算四则混合运算的值的函数：
doublecomputer（BTREEbt），其中，参数bt为四则运算所对应的树，返回值为计算结果。
提示：
先求树的的波兰表达式，然后利用栈结构计算表达式的值。
在主函数中进行测试，求2+3*（5+8）/4-5的值。
要求：
1、上述作业要求在单独完成；
2、完成后，于规定期限内提交到ftp服务器的相应目录中中，注意，在提交时将所编写的程序统一拷贝到一个Word文件中，文件名格式为“学号+姓名”
三
四
五、六代码
#include
usingnamespacestd;
typedefchardatatype;
structnode{
node*lchild;
datatypedata;
node*rchild;
};
typedefnode*BTREE;
voidCreateBTREE（BTREE&BT,char*&str）//先根输入树
{
charch;
ch=*str++;
if（ch=='#'）
BT=NULL;
else
{
BT=newnode;
BT->data=ch;
CreateBTREE（BT->lchild,str）;
CreateBTREE（BT->rchild,str）;
}
}
voidEmpty（BTREEBT）
{
BT=NULL;
}
boolIsEmpty（BTREEBT）//判断是否为空
{
if（BT==NULL）
returntrue;
else
returnfalse;
}
BTREECreateBT（datatypev,BTREEltree,BTREErtree）//用左右子树建立二叉树
{
BTREEroot;
root=newnode;
root->data=v;
root->lchild=ltree;
root->rchild=rtree;
returnroot;
}
BTREELchild（BTREEBT）//返回左子树
{
returnBT->lchild;
}
BTREERchild（BTREEBT）//返回右子树
{
returnBT->rchild;
}
datatypeData（BTREEBT）//返回节点元素值
{
returnBT->data;
}
voidvisit（datatypedt）
{
cout<}
voidPreOrder（BTREEBT）//先根顺序遍历
{
if（!
IsEmpty（BT））
{
visit（Data（BT））;
PreOrder（Lchild（BT））;
PreOrder（Rchild（BT））;
}
}
voidInOrder（BTREEBT）//中根顺序遍历
{
if（!
IsEmpty（BT））
{
PreOrder（Lchild（BT））;
visit（Data（BT））;
PreOrder（Rchild（BT））;
}
}
voidPostOrder（BTREEBT）//后根顺序遍历
{
if（!
IsEmpty（BT））
{
PreOrder（Lchild（BT））;
PreOrder（Rchild（BT））;
visit（Data（BT））;
}
}
intcount2（BTREEBT）
{
if（BT==NULL）
return0;
else
{
if（（BT->lchild）&&（BT->rchild））
return1+count2（Lchild（BT））+count2（Rchild（BT））;
if（（BT->lchild）&&（BT->rchild==NULL））
returncount2（Lchild（BT））;
if（（BT->lchild==NULL）&&（BT->rchild））
returncount2（Rchild（BT））;
}
}
intleafnum（BTREEBT）
{
staticintcount=0;
if（BT->lchild==NULL&&BT->rchild==NULL）
return++count;
else
{
leafnum（Lchild（BT））;
leafnum（Rchild（BT））;
}
}
intmain（）
{
BTREEBT=NULL;
char*str="abc##d##ef##g##";
CreateBTREE（BT,str）;
cout<<"度为2的节点的个数:
"<cout<<"叶子节点个数：
"<}
七
中序线索二叉树
先序线索二叉树
八
二叉树
后序线索二叉树
九
#include
usingnamespacestd;
typedefchardatatype;
structnode{
node*lchild;
node*rchild;
boolltag;
boolrtag;
datatypedata;
};
typedefnode*THTREE;
THTREEInPre（THTREEP）//求中序前驱（右子树的最左节点）
{
THTREEQ=P->lchild;
if（P->ltag==true）
while（Q->rtag==true）
Q=Q->rchild;
returnQ;
}
THTREEInNext（THTREEP）//求中序后继（左子树的最右节点）
{
THTREEQ=P->rchild;
if（P->rtag==true）
while（Q->ltag==true）
Q=Q->lchild;
returnQ;
}
//二叉树中插入一个结点Q作为树中某个结点P的左孩子
voidLInsert（THTREEP,THTREEQ）
{
THTREEW;
Q->lchild=P->lchild;
Q->ltag=P->ltag;
Q->rchild=P;
Q->rtag=false;
P->lchild=Q;
P->ltag=true;
if（Q->ltag==true）//如果P节点有左孩子
{
W=InPre（Q）;
W->rchild=Q;
}
}
voidRInsert（THTREEP,THTREEQ）
{
THTREEW;
Q->rchild=P->rchild;
Q->rtag=P->rtag;
Q->lchild=P;
Q->ltag=false;
P->rchild=Q;
P->rtag=true;
if（Q->rtag==true）//如果P节点有右孩子
{
W=InNext（Q）;
W->lchild=Q;
}
}
voidThInOrder（THTREEHEAD）
{
THTREEtemp;
temp=HEAD;
do{
temp=InNext（temp）;
if（temp!
=HEAD）
cout<<（temp->data）;
}while（temp!
=HEAD）;
}
intmain（）
{
node*HEAD=newnode;
node*A=newnode;
HEAD->data='!
';
A->data='A';
HEAD->lchild=A;
HEAD->rchild=HEAD;
HEAD->ltag=true;
HEAD->rtag=true;
A->lchild=HEAD;
A->rchild=HEAD;
A->ltag=false;
A->rtag=false;
node*B=newnode;
B->data='B';
node*C=newnode;
C->data='C';
node*D=newnode;
D->data='D';
node*E=newnode;
E->data='E';
node*F=newnode;
F->data='F';
node*G=newnode;
G->data='G';
LInsert（A,B）;
RInsert（A,C）;
LInsert（B,D）;
RInsert（B,E）;
LInsert（C,F）;
RInsert（C,G）;
ThInOrder（HEAD）;
}
十
2
6
31
5
82
49
7
16
44
2
6
31
5
82
49
7
16
十一
#include
#defineMaxSize200
usingnamespacestd;
typedefstruct{
intdata;
}Elementtype;
typedefstruct{
Elementtypeelements[MaxSize];
intn;
}HEAP;
voidMaxHeap（HEAP&heap）//创建一个空堆
{
heap.n=0;
}
boolHeapEmpty（HEAPheap）//判断是否为空堆
{
return（!
heap.n）;
}
boolHeapFull（HEAPheap）//判断是否满堆
{
return（heap.n==MaxSize-1）;
}
voidInsert（HEAP&heap,Elementtypeelement）//最大堆插入一个元素
{
inti;
if（!
HeapFull（heap））
{
i=++heap.n;
while（i!
=1&&（element.data>heap.elements[i/2].data））
{
heap.elements[i]=heap.elements[i/2];
i/=2;
}
}
heap.elements[i]=element;
}
ElementtypeDeleteMax（HEAP&heap）//删除堆中的最大元素
{
intparent=1,child=2;
Elementtypeelement,tmp;
if（!
HeapEmpty（heap））
{
element=heap.elements[1];
tmp=heap.elements[heap.n--];
while（child<=heap.n）
{
if（（childchild++;
if（tmp.data>=heap.elements[child].data）
break;
heap.elements[parent]=heap.elements[child];
parent=child;
child*=2;
}
heap.elements[parent]=tmp;
returnelement;
}
}
intFind（HEAP&H,Elementtypee）//查找e是否为堆中元素
{
inti=H.n,j;
if（e.data==H.elements[1].data）
return1;
if（i!
=0）
{
if（e.data==H.elements[i].data）
returni;
elseif（（e.data
升级会员 