1．选择题
（ 1）把一棵树转换为二叉树后，这棵二叉树的形态是（） 。D、

（ 4）一个具有 1025 个结点的二叉树的高 h 为（）。

（ 11）设哈夫曼树中有 199 个结点，则该哈夫曼树中有（）个叶子结点。
②画出这棵二叉树的后序线索树。E、

（ 5）深度为 h 的满 m叉树的第 k 层有（）个结点。两个权值最小的结点一定是兄弟结点、
A．唯一的
Ｂ．有多种
C．有多种，但根结点都没有左孩子
Ｄ．有多种，但根结点都没有右孩子
答案： A
解释：因为二叉树有左孩子、
② 试设计另一种由二进制表示的等长编码方案。 B、右孩子之分，故一棵树转换为二叉树后，这棵二叉树的
形态是唯一的。
[ 题目分析 ] 因为后序遍历栈中保留当前结点的祖先的信息，用一变量保存栈的最高栈顶
指针，每当退栈时，栈顶指针高于保存最高栈顶指针的值时，则将该栈倒入辅助栈中，辅助
栈始终保存最长路径长度上的结点，直至后序遍历完毕，则辅助栈中内容即为所求。7、孩子兄弟表示法，其中孩子兄弟表示法是常用的表示法，任意一棵树都能通过孩子兄弟表示法转换为二叉树进行存储。
[ 算法描述 ]

int LeafNodeCount(BiTree T) {     if(T==NULL)         return 0; // 如果是空树，则叶子结点个数为 0     else if(T->lchild==NULL&&T->rchild==NULL)         return 1; // 判断结点是否是叶子结点（左孩子右孩子都为空） ，若是则返回 1     else         return LeafNodeCount(T->lchild)+LeafNodeCount(T->rchild); } 

（ 2）判别两棵树是否相等
[ 算法描述 ]

int compareTree(TreeNode* tree1, TreeNode* tree2) //用分治的方法做，比较当前根，然后比较左子树和右子树{    bool tree1IsNull = (tree1==NULL);     bool tree2IsNull = (tree2==NULL);     if(tree1IsNull != tree2IsNull)     {         return 1;     }     if(tree1IsNull && tree2IsNull)     {// 如果两个都是 NULL ，则相等        return 0;     }// 如果根节点不相等，直接返回不相等，否则的话，看看他们孩子相等不相等    if(tree1->c != tree2->c)     {         return 1;     }     return (compareTree(tree1->left,tree2->left)&compareTree(tree1->right,tree2->right))     (compareTree(tree1->left,tree2->right)&compareTree(tree1->right,tree2->left)); }// 算法结束

（ 3）交换二叉树每个结点的左孩子和右孩子。再右孩子、
③将这棵二叉树转换成对应的树（或森林） 。任一非叶结点
的权值一定不小于下一层任一结点的权值。
[ 算法描述 ]

void DoubleTraverse(BiTree T) {     if(T == NULL)         return;     else if(T->lchild==NULL&&T->rchild==NULL)         cout<<T->data; // 叶子结点输出    else     {         cout<<T->data;         DoubleTraverse(T->lchild); // 递归遍历左子树        cout<<T->data;         DoubleTraverse(T->rchild); // 递归遍历右子树    } } 

（ 5）计算二叉树最大的宽度 （二叉树的最大宽度是指二叉树所有层中结点个数的最大值） 。
A．加快查找结点的前驱或后继的速度
B．为了能在二叉树中方便的进行插入与删除
C．为了能方便的找到双亲
D．使二叉树的遍历结果唯一
答案： A

（ 14）设 F 是一个森林， B 是由 F 变换得的二叉树。
[ 题目分析 ] 如果二叉树为空，返回 0，如果二叉树不为空且左右子树为空，返回 1，如果
二叉树不为空，且左右子树不同时为空，返回左子树中叶子节点个数加上右子树中叶子
节点个数。
[ 算法描述 ]

int Width(BiTree bt)// 求二叉树 bt 的最大宽度{    if (bt==null) return (0); // 空二叉树宽度为 0     else     {        BiTree Q[];//Q 是队列，元素为二叉树结点指针，容量足够大        front=1;rear=1;last=1;         //front 队头指针 ,rear 队尾指针 ,last 同层最右结点在队列中的位置        temp=0; maxw=0; //temp 记局部宽度 , maxw 记最大宽度        Q[rear]=bt; // 根结点入队列        while(front<=last)         {            p=Q[front++]; temp++; // 同层元素数加 1             if (p->lchild!=null) Q[++rear]=p->lchild; // 左子女入队            if (p->rchild!=null) Q[++rear]=p->rchild; // 右子女入队                if (front>last) // 一层结束，            {                last=rear;                 if(temp>maxw) maxw=temp;                 //last 指向下层最右元素 , 更新当前最大宽度                temp=0;             }//if         }//while         return (maxw);     }}// 结束 width 

（ 6）用按层次顺序遍历二叉树的方法，统计树中具有度为 1 的结点数目。

2．应用题
（1）试找出满足下列条件的二叉树
① 先序序列与后序序列相同②中序序列与后序序列相同
③ 先序序列与中序序列相同④中序序列与层次遍历序列相同
答案：先序遍历二叉树的顺序是“根—左子树—右子树” ，中序遍历“左子树—根—右
子树”，后序遍历顺序是： “左子树—右子树―根＂，根据以上原则有
①或为空树，或为只有根结点的二叉树
② 或为空树，或为任一结点至多只有左子树的二叉树．
③ 或为空树，或为任一结点至多只有右子树的二叉树．
④或为空树，或为任一结点至多只有右子树的二叉树

（2）设一棵二叉树的先序序列： A B D F C E G H ，中序序列： B F D A G E H C
①画出这棵二叉树。右子树的位置，利用（）遍历方法最合适。
[ 题目分析 ] 如果某结点左右子树为空，返回，否则交换该结点左右孩子，然后递归交换
左右子树。

（ 10）一棵非空的二叉树的先序遍历序列与后序遍历序列正好相反，则该二叉树一定满
足（）。 求最大宽度可采用层次遍历的方法， 记下各层
结点数，每层遍历完毕，若结点数大于原先最大宽度，则修改最大宽度。
①试为这 8 个字母设计赫夫曼编码。右孩子的编号，同一结点的左右孩子中，其左孩子的编号小于其右孩子的编号，可采用（）遍历实现编号。
答案：

3．算法设计题
以二叉链表作为二叉树的存储结构，编写以下算法：
（ 1）统计二叉树的叶结点个数。
A． n- 1 B． n C． n + 1 D． n + 2
答案： C

（ 15）n（ n≥2）个权值均不相同的字符构成哈夫曼树， 关于该树的叙述中， 错误的是 （ ）。

（ 2）由 3 个结点可以构造出多少种不同的二叉树？（）
A． 2 B ． 3 C ． 4 D ． 5
答案： D

（ 3）一棵完全二叉树上有 1001 个结点，其中叶子结点的个数是（） 。 G的权值分别为 3、

（ 9）在下列存储形式中， （）不是树的存储形式？
A．双亲表示法 B ．孩子链表表示法 C．孩子兄弟表示法 D．顺序存储表示法
答案： D
解释：树的存储结构有三种：双亲表示法、
A．先序 B. 中序 C. 后序 D. 从根开始按层次遍历
答案： C
解释：根据题意可知按照先左孩子、

（ 8）若二叉树采用二叉链表存储结构，要交换其所有分支结点左、

（ 12）若 X 是二叉中序线索树中一个有左孩子的结点，且 X 不为根，则 X 的前驱为（） 。
A． 99 B． 100
C． 101 D． 102
答案： B
解释：在哈夫曼树中没有度为 1 的结点，只有度为 0（叶子结点）和度为 2 的结点。 (1=<k=<h)
A． m^(k-1)
B． m^k-1
C． m^(h-1)
D． m^h-1
答案： A
解释：深度为 h 的满 m 叉树共有 mh
-1 个结点，第 k 层有 m
k-1 个结点。
答案：方案 1；哈夫曼编码
先将概率放大 100 倍，以方便构造哈夫曼树。[ 题目分析 ] 若树为空，返回；若某结点为叶子结点，则仅输出该结点；否则先输出该结
点，递归遍历其左子树，再输出该结点，递归遍历其右子树。
A．指向最左孩子 B ．指向最右孩子 C ．空 D ．非空
答案： C
解释：利用二叉链表存储树时，右指针指向兄弟结点，因为根节点没有兄弟结点，故根节点的右指针指向空。 [ 题目分析 ] 求二叉树高度的算法见上题。
③对于上述实例，比较两种方案的优缺点。若 F 中有 n 个非终端结点，则 B 中右指针域为空的结点有（ ）个。
w={7,19,2,6,32,3,21,10} ，按哈夫曼规则： 【 [ (2,3)， 6], (7,10) 】 … 19,21,32

方案 1 的 WPL ＝ 2(0.19+0.32+0.21)+4(0.07+0.06+0.10)+5(0.02+0.03)=1.44+0.92+0.25=2.61
方案 2 的 WPL ＝ 3(0.19+0.32+0.21+0.07+0.06+0.10+0.02+0.03)=3
结论：哈夫曼编码优于等长二进制编码

方案比较

（ 4）已知下列字符 A、
答案

（ 3）假设用于通信的电文仅由 8 个字母组成， 字母在电文中出现的频率分别为 0.07 ，0.19 ，
0.02 ， 0.06 ， 0.32 ， 0.03 ， 0.21 ， 0.10 。
A．前序 B．中序 C．后序 D ．按层次
答案： C
解释：后续遍历和层次遍历均可实现左右子树的交换 ，不过层次遍历的实现消耗比后续大，后序遍历方法最合适。设叶子结点的个数为 n0，度为 2 的结点的个数为 n2，由二叉树的性质 n0=n2+1 ，则总结点数 n= n0+n2=2*n0-1 ，得到 n0=100 。 F、

（ 6）利用二叉链表存储树，则根结点的右指针是（） 。B 不能选，又所有的结点均无左孩子与所有的结
点均无右孩子时，均只有一个叶子结点，故选 C。则所有的结点均无左
孩子或所有的结点均无右孩子均可，所以 A、孩子表示法、 2、
[题目分析 ]
若某个结点左子树空右子树非空或者右子树空左子树非空，则该结点为度为 1 的结点
[算法描述 ]

int Level(BiTree bt) // 层次遍历二叉树，并统计度为 1 的结点的个数{    int num=0; //num 统计度为 1 的结点的个数    if(bt)    {        QueueInit(Q); QueueIn(Q,bt);//Q 是以二叉树结点指针为元素的队列        while(!QueueEmpty(Q))         {            p=QueueOut(Q); cout<<p->data; // 出队 , 访问结点            if(p->lchild && !p->rchild ||!p->lchild && p->rchild)    num++;             // 度为 1 的结点            if(p->lchild) QueueIn(Q,p->lchild); // 非空左子女入队            if(p->rchild) QueueIn(Q,p->rchild); // 非空右子女入队        } //while(!QueueEmpty(Q))     }//if(bt)     return(num); }// 返回度为 1 的结点的个数

（ 7）求任意二叉树中第一条最长的路径长度，并输出此路径上各结点的值。
A．该树一定是一棵完全二叉树
B．树中一定没有度为 1 的结点
C．树中两个权值最小的结点一定是兄弟结点
D．树中任一非叶结点的权值一定不小于下一层任一结点的权值
答案： A
解释：哈夫曼树的构造过程是每次都选取权值最小的树作为左右子树构造一棵新的二叉
树，所以树中一定没有度为 1 的结点、
A． 11 B ． 10 C ． 11 至 1025 之间 D． 10 至 1024 之间
答案： C
解释：若每层仅有一个结点，则树高 h 为 1025 ；且其最小树高为 log 2 1025 + 1=11 ， 即 h 在 11 至 1025 之间。最后双亲结点的顺序遍历二叉树，即后序遍历二叉树。
[ 算法描述 ]

void AllPath(BTNode *b,ElemType path[],int pathlen) {    int i;     if (b!=NULL)     {        if (b->lchild==NULL && b->rchild==NULL) //*b 为叶子结点        {            cout << " " << b->data << " 到根结点路径 :" << b->data;             for (i=pathlen-1;i>=0;i--)                 cout << endl;         }         else         {            path[pathlen]=b->data; // 将当前结点放入路径中            pathlen++; //路径长度增 1             AllPath(b->lchild,path,pathlen); // 递归扫描左子树            AllPath(b->rchild,path,pathlen); // 递归扫描右子树            pathlen--; //恢复环境        }     }//if (b!=NULL) }// 算法结束