1.一颗二叉树的括号表示为“1(2(4，5(6，7))，3)”）。设N代表二叉树的根，L代表根节点的左子树，R代表根节点的右子树。若遍历后的节点序列为3，1，7，5，6，2，4，则其遍历方式是（ B）。
A.LRN
B.RNL
C.NRL
D.RLN
2.若二叉树（每个节点值为单个字符）的中序遍历序列是abcdef，且c为根节点，则（ D）。
A.以上都不对
B.二叉树有两个度为0的节点
C.二叉树的高度为5
D.节点c有两个孩子
3.若知道一棵二叉树的（ C），便可以唯一确定该二叉树。
A.先序和后序序列
B.中序序列
C.中序和后序序列
D.先序序列
4.一棵二叉树的先序遍历序列为ABCDEFG，它的中序遍历序列可能是（ D）。
A.ADCFEG
B.CABDEFG
C.DACEFBG
D.ABCDEFG
解析： D、当一棵二叉树所有节点的左子树为空时，先序遍历序列和中序遍历序列相同。先序序列和中序序列可以确定一棵二叉树，这里由选项A、C和D的中序序列无法确定一棵二叉树。
5.一棵二叉树的先序遍历序列为ABCDEF，中序遍历序列为CBAEDF，则后序遍历序列为（C ）
A.CBEDFA
B.FEDCBA
C.CBEFDA
D.不确定
6.某棵二叉树中，X节点有左孩子Y节点，则在其先序遍历中（B ）。
A.访问X节点后，接着遍历Y节点的左子树，然后访问Y节点
B.访问X节点后立即访问Y节点
C.访问Y节点后，接着遍历Y节点的左子树，然后访问X节点
D.访问Y节点后立即访问X节点
7.关于二叉树（含2个以上的节点）的先序遍历序列中，以下正确的是（B ）。
A.先序遍历序列的第一个节点一定是叶子节点
B.先序遍历序列的最后一个节点一定是叶子节点
C.先序遍历序列的最后一个节点是根节点
D.以上都不对
8.若一棵完全二叉树中每个节点值为单个字符，其后序遍历序列为CDBFGEA，则其先序遍历序列是（ C）。
A.CBDAFEG
B.无法确定
C.ABCDEFG
D.ABECDFG
9.任何一棵二叉树的叶子节点在先序、中序和后序遍历序列中的相对次序（ B）。
A.以上都不对
B.相同
C.不相同
D.不能确定
10.若二叉树采用二叉链存储结构，要删除该二叉链中所有节点并释放它们占用的空间，利用（ C）遍历方法最合适。
A.先序
B.中序
C.后序
D.层次
解析： C、先释放左子树的空间，再释放右子树的空间，最后释放根节点的空间。
11.判断线索二叉树中p节点为叶子节点的条件是（B ）。
A.p->ltag= =0 && p->rtag= =0
B.p->ltag= =1 && p->rtag= =1
C.p->ltag= =1
D.p->lchild= =NULL && p->rchild= =NULL
解析： B、p节点左、右指针均为线索，表示它们原来都为空，即为叶子节点。
12.n个节点的线索二叉树上含有的线索个数为（C ）。
A.n
B.n-1
C.n+1
D.2n
解析： C、n个节点的指针域个数为2n，指向孩子的指针域个数为n-1，所以线索个数=2n-(n-1)=n+1
13.设有一棵哈夫曼树的节点总数为35，则该哈夫曼树共有（B ）个叶子节点。
A.30
B.18
C.35
D.20
解析： B、2n0-1=35，则n0=18。
14.根据使用频率为5个字符设计的哈夫曼编码不可能是（ B）。
A.111，110，10，01，00
B.100，11，10，1，0
C.000，001，010，011，1
D.001，000，01，11，10
15.下面关于哈夫曼树的说法，错误的是（C ）。
A.对应于一组权值构造出的哈夫曼树可能不是唯一的
B.哈夫曼树具有最小带权路径长度
C.哈夫曼树中除了度为1的节点外，还有度为2的节点和叶子节点
D.哈夫曼树中没有度为1的节点
1 .若某非空二叉树的先序序列和后序序列正好相同，则该二叉树的形态是什么？
答：空或只有一个节点。
2 .一棵二叉树的先序、中序和后序序列分别如下，其中有一部分未显示出来。试求出空格处的内容，并画出该二叉树。
先序序列： B F ICEH G
中序序列：D KFIA EJC
后序序列： K FBHJ G A
答：
先序序列：ABDFKICEHJG
中序序列：DBKFIAHEJCG
后序序列：DKIFBHJEGCA
(A(B(D,F(K,I)),C(E(H,J),G)))
3 .一棵二叉树采用二叉链存储结构b表示，所有节点值均不相同，有以下算法：
int fun(BTNode *b)
{ int num1，num2，n;
if (b= =NULL)
return 0;
else if ((b->lchild= =NULL && b->rchild!=NULL) ||
(b->lchild!=NULL && b->rchild==NULL))
n=1;
else
n=0;
num1=fun(b->lchild);
num2=fun(b->rchild);
return (num1+num2+n);
}
（1）指出fun(b)算法的功能。
（2）当二叉树b的括号表示为" A(B(D(，G))，C(E，F))"时，执行fun(b)后其返回结果是么？
答：（1）计算度为1的节点个数
（2）2
4 .给出在中序线索二叉树中查找节点p的后继节点的过程。
答：
void Thread(TBTNode *&p)
{
if(p!=NULL)
{
Thread(p->lchild);
if(p->lchild==NULL)
{
p->lchile=pre;
p->ltag=1;
}
else p->ltag=0;
if(pre->rchild==NULL)
{
pre->rchild=p;
pre->rtag=1;
}
else pre->rtag=0;
pre=p;
Thread(p->rchild);
}
}
5 .如果一棵哈夫曼树T中共有255个节点，那么该树用于对几个字符进行哈夫曼编码？
答：128个。
6 .假设二叉树中每个节点值为单个字符，采用二叉链存储结构存储。设计一个算法void findparent(BTNode *b，char x，BTNode *&p)求二叉树b中指定值为x的节点的双亲节点p，提示：根节点的双亲为NULL，若在b中未找到值为x的节点，p亦为NULL，并假设二叉树中所有节点值是唯一的。
答：
BTNode *findparent(BTNode *b,char x)
{
cout<<b->lchild->data<<" "<<b->rchild->data<<endl;
BTNode *p;
if(b==NULL) return NULL;
else if(b->lchild->data==x||b->rchild->data==x) return b;
else
{
p=findparent(b->lchild,x);
if(p==NULL) return findparent(b->rchild,x);
}
}
7 .假设二叉树中每个节点值为单个字符，采用二叉链存储结构存储。设计一个算法求二叉树b的最小枝长。所谓最小最小枝长是指的是根节点到最近叶子节点的路径长度。
答：
#include <iostream>
#include <stdlib.h>
using namespace std;
const int MaxSize=100;
typedef struct node
{
char data;
struct node *lchild,*rchild;
}BTNode;
void CreatBTNode(BTNode *&b,char *str)
{
BTNode *St[MaxSize],*p;
int top=-1,k,j=0;
char ch;
b=NULL;
ch=str[j];
while(ch!='\0')
{
switch(ch)
{
case'(':top++;
St[top]=p;
k=1;
break;
case')':top--;
break;
case',':k=2;
break;
default:
p=(BTNode *)malloc(sizeof(BTNode));
p->data=ch;
p->lchild=p->rchild=NULL;
if(b==NULL) b=p;
else
{
switch(k)
{
case 1:St[top]->lchild=p; break;
case 2:St[top]->rchild=p; break;
}
}
}
j++;
ch=str[j];
}
}
int run(BTNode *root)
{
if(root==NULL)
return 0;
if((root->lchild==NULL)&&(root->rchild==NULL))
return 1;
if(root->lchild==NULL)
return run(root->rchild)+1;
if(root->rchild==NULL)
return run(root->lchild)+1;
return min(run(root->rchild)+1,run(root->lchild)+1);
}
int main()
{
BTNode *b;
char str[100]="A(B(D(H,I),E),C(F(J,K),G(L,M)))";
CreatBTNode(b,str);
cout<<run(b);
return 0;
}
8 .假设二叉树中每个节点值为单个字符，采用二叉链存储结构存储。设计一个算法，求二叉树b中第k层（根节点的层次为1）上节点个数。
答：
#include <iostream>
#include <stdlib.h>
using namespace std;
const int MaxSize=100;
int k,m=0;
typedef struct node
{
char data;
struct node *lchild,*rchild;
}BTNode;
BTNode *t,*r;
void CreatBTNode(BTNode *&b,char *str)
{
BTNode *St[MaxSize],*p;
int top=-1,k,j=0;
char ch;
b=NULL;
ch=str[j];
while(ch!='\0')
{
switch(ch)
{
case'(':top++;
St[top]=p;
k=1;
break;
case')':top--;
break;
case',':k=2;
break;
default:
p=(BTNode *)malloc(sizeof(BTNode));
p->data=ch;
p->lchild=p->rchild=NULL;
if(b==NULL) b=p;
else
{
switch(k)
{
case 1:St[top]->lchild=p; break;
case 2:St[top]->rchild=p; break;
}
}
}
j++;
ch=str[j];
}
}
void DispBTNode(BTNode *b)
{
if(b!=NULL)
{
cout<<b->data;
if(b->lchild!=NULL||b->rchild!=NULL)
{
cout<<"(";
DispBTNode(b->lchild);
if(b->rchild!=NULL)
cout<<",";
DispBTNode(b->rchild);
cout<<")";
}
}
}
int level(BTNode *b,char x,int h)
{
int l;
if(b==NULL) return 0;
else if(b->data==x) return h;
else
{
l=level(b->lchild,x,h+1);
if(l==0) return level(b->rchild,x,h+1);
else return l;
}
}
int PreOrder(BTNode *b,int k)
{
r=t;
if(b!=NULL)
{
if(level(r,b->data,1)==k) m++;
PreOrder(b->lchild,k);
PreOrder(b->rchild,k);
}
return m;
}
int main()
{
BTNode *b;
char str[100]="A(B(D(H,I),E),C(F(J,K),G(L,M)))";
CreatBTNode(b,str);
t=b;
cin>>k;
cout<<PreOrder(b,k);
return 0;
}
9 .假设二叉树中每个节点值为单个字符，采用二叉链存储结构存储。设计一个算法，输出二叉树b中第k层（根节点的层次为1）上的所有叶子节点。
答：
#include <iostream>
#include <stdlib.h>
using namespace std;
const int MaxSize=100;
int k,m=0;
typedef struct node
{
char data;
struct node *lchild,*rchild;
}BTNode;
BTNode *t,*r;
void CreatBTNode(BTNode *&b,char *str)
{
BTNode *St[MaxSize],*p;
int top=-1,k,j=0;
char ch;
b=NULL;
ch=str[j];
while(ch!='\0')
{
switch(ch)
{
case'(':top++;
St[top]=p;
k=1;
break;
case')':top--;
break;
case',':k=2;
break;
default:
p=(BTNode *)malloc(sizeof(BTNode));
p->data=ch;
p->lchild=p->rchild=NULL;
if(b==NULL) b=p;
else
{
switch(k)
{
case 1:St[top]->lchild=p; break;
case 2:St[top]->rchild=p; break;
}
}
}
j++;
ch=str[j];
}
}
void DispBTNode(BTNode *b)
{
if(b!=NULL)
{
cout<<b->data;
if(b->lchild!=NULL||b->rchild!=NULL)
{
cout<<"(";
DispBTNode(b->lchild);
if(b->rchild!=NULL)
cout<<",";
DispBTNode(b->rchild);
cout<<")";
}
}
}
int level(BTNode *b,char x,int h)
{
int l;
if(b==NULL) return 0;
else if(b->data==x) return h;
else
{
l=level(b->lchild,x,h+1);
if(l==0) return level(b->rchild,x,h+1);
else return l;
}
}
void PreOrder(BTNode *b,int k)
{
r=t;
if(b!=NULL)
{
if(level(r,b->data,1)==k) cout<<b->data<<" ";
PreOrder(b->lchild,k);
PreOrder(b->rchild,k);
}
}
int main()
{
BTNode *b;
char str[100]="A(B(D(H,I),E),C(F(J,K),G(L,M)))";
CreatBTNode(b,str);
t=b;
cin>>k;
PreOrder(b,k);
return 0;
}
10 .假设二叉树中每个节点值为单个字符，采用二叉链存储结构存储。设计一个算法，判断值为x的节点与值为y的节点是否互为兄弟，假设这样的节点值是唯一的。
答：
#include <iostream>
#include <stdlib.h>
using namespace std;
const int MaxSize=100;
int k,m=0;
typedef struct node
{
char data;
struct node *lchild,*rchild;
}BTNode;
void CreatBTNode(BTNode *&b,char *str)
{
BTNode *St[MaxSize],*p;
int top=-1,k,j=0;
char ch;
b=NULL;
ch=str[j];
while(ch!='\0')
{
switch(ch)
{
case'(':top++;
St[top]=p;
k=1;
break;
case')':top--;
break;
case',':k=2;
break;
default:
p=(BTNode *)malloc(sizeof(BTNode));
p->data=ch;
p->lchild=p->rchild=NULL;
if(b==NULL) b=p;
else
{
switch(k)
{
case 1:St[top]->lchild=p; break;
case 2:St[top]->rchild=p; break;
}
}
}
j++;
ch=str[j];
}
}
void DispBTNode(BTNode *b)
{
if(b!=NULL)
{
cout<<b->data;
if(b->lchild!=NULL||b->rchild!=NULL)
{
cout<<"(";
DispBTNode(b->lchild);
if(b->rchild!=NULL)
cout<<",";
DispBTNode(b->rchild);
cout<<")";
}
}
}
bool judge(BTNode *b,char x,char y)
{
if(b==NULL) return false;
if(b->lchild!=NULL&&b->rchild!=NULL)
{
if(b->lchild->data==x&&b->rchild->data==y||b->lchild->data==y&&b->rchild->data==x)
return true;
}
if(judge(b->lchild,x,y)) return true;
else return judge(b->rchild,x,y);
}
int main()
{
BTNode *b;
char x='B',y='C';
char str[100]="A(B(D(H,I),E),C(F(J,K),G(L,M)))";
CreatBTNode(b,str);
if(judge(b,x,y)) cout<<"yes";
else cout<<"no";
return 0;
}