实验内容
1、假设二叉树中的每个结点值为单个字符，采用二叉链存储结构存储。设计一个算法，计算一棵给定二叉树b中的所有单分支结点个数。
2.假设二叉树中的每个结点值为单个字符，采用二叉链存储结构存储。设计一个算法，求二叉树b中最小值的结点值。
3、编写一个程序，实现二叉树的基本运算，并在此基础上完成以下功能：
（1）由图7.33所示的二叉树创建对应的二叉链存储结构b，该二叉树的括号表示串为“A（B（D，E（H（J,K（L,M（，N））））），C（F,G（，I）））”。
（2）输出二叉树b。
（3）输出‘H’结点的左右孩子结点值。
（4）输出二叉树b的高度。
（5）释放二叉树b。
4、编写一个程序，实现二叉树的先序遍历、中序遍历和后序遍历的递归和非递归算法，以及层次遍历的算法，并对图7.33所示的二叉树b给出求解结果。
5、编写一个程序，实现由先序序列和中序序列以及由中序序列和后序序列构造一颗二叉树的功能（二叉树中的每个结点值为单个字符），要求以括号表示和凹入表示法输出该二叉树，并用先序遍历序列“ABDEHJKLMNCFGI”和中序遍历序列“DBJHLKMNEAFCGI”以及由中序遍历序列“DBJHLKMNEAFCGI”和后序遍历序列“DJLNMKHEBFIGCA”进行验证。
6、编写一个程序实现以下功能，并对图7.33所示的二叉树进行验证。
（1）输出二叉树b的结点个数。
（2）输出二叉树b的叶子节点个数。
（3）求二叉树b中指定结点值（假设所有结点值不同）的结点的层次。
（4）利用层次遍历求二叉树b的宽度。
代码实现
1、
#include <iostream>
#include <malloc.h>
using namespace std;
#define MaxSize 50
typedef struct node
{
char data;
struct node *lchild;
struct node *rchild;
}BTNode;
//创建二叉树
void CreateBTree(BTNode *&b,const 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 DispBTree(BTNode *b)
{
if(b!=NULL)
{
printf("%c",b->data);
if(b->lchild!=NULL||b->rchild!=NULL)
{
printf("(");
DispBTree(b->lchild);
if(b->rchild!=NULL)
printf(",");
DispBTree(b->rchild);
printf(")");
}
}
}
//销毁二叉树
void DestroyBTree(BTNode *&b)
{
if(b!=NULL)
{
DestroyBTree(b->lchild);
DestroyBTree(b->rchild);
free(b);
}
}
//求单节点个数(先序遍历)
int SSonNodes(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=SSonNodes(b->lchild);//递归求左子树中单分支结点数
num2=SSonNodes(b->rchild);//递归求右子树中单分支结点数
return (num1+num2+n);
}
int main()
{
BTNode *b;
CreateBTree(b,"A(B(D(,G)),C(E,F))");
cout<<"二叉树为："<<endl;
DispBTree(b);
cout<<endl;
cout<<"单分支结点个数为：";
cout<<SSonNodes(b);
DestroyBTree(b);
return 0;
}
结果截图：
2、
#include <iostream>
#include <malloc.h>
using namespace std;
#define MaxSize 50
typedef struct node
{
char data;
struct node *lchild;
struct node *rchild;
}BTNode;
//创建二叉树
void CreateBTree(BTNode *&b,const 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 DispBTree(BTNode *b)
{
if(b!=NULL)
{
printf("%c",b->data);
if(b->lchild!=NULL||b->rchild!=NULL)
{
printf("(");
DispBTree(b->lchild);
if(b->rchild!=NULL)
printf(",");
DispBTree(b->rchild);
printf(")");
}
}
}
//销毁二叉树
void DestroyBTree(BTNode *&b)
{
if(b!=NULL)
{
DestroyBTree(b->lchild);
DestroyBTree(b->rchild);
free(b);
}
}
//找最小值的结点值
void FindMinNode(BTNode *b,char &min)
{
if(b->data<min)
min=b->data;
FindMinNode(b->lchild,min);//在左子树中找最小结点值
FindMinNode(b->rchild,min);//在右子树中找最小结点值
}
//输出最小结点值
void MinNode(BTNode *b)
{
if(b!=NULL)
{
char min=b->data;
printf("Min=%c\n",min);
}
}
int main()
{
BTNode *b;
CreateBTree(b,"A(B(D(,G)),C(E,F))");
cout<<"二叉树为："<<endl;
DispBTree(b);
cout<<endl;
cout<<"最小结点值为：";
MinNode(b);
DestroyBTree(b);
return 0;
}
结果截图：
3、
#include <iostream>
#include <malloc.h>
using namespace std;
#define MaxSize 50
typedef char ElemType;
typedef struct node
{
char data;
struct node *lchild;
struct node *rchild;
}BTNode;
//创建二叉树
void CreateBTree(BTNode *&b,const 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 DestroyBTree(BTNode *&b)
{
if(b!=NULL)
{
DestroyBTree(b->lchild);
DestroyBTree(b->rchild);
free(b);
}
}
//查找结点
BTNode *FindNode(BTNode *b,ElemType x)
{
BTNode *p;
if(b==NULL)
return NULL;
else if(b->data==x)
return b;
else
{
p=FindNode(b->lchild,x);
if(p!=NULL)
return p;
else
return FindNode(b->rchild,x);
}
}
//找孩子结点
BTNode *LchildNode(BTNode *p)
{
return p->lchild;
}
BTNode *RchildNode(BTNode *p)
{
return p->rchild;
}
//求高度
int BTHeight(BTNode *b)
{
int lchild,rchild;
if(b==NULL) return (0);
else
{
lchild=BTHeight(b->lchild);
rchild=BTHeight(b->rchild);
return (lchild>rchild)?(lchild+1):(rchild+1);
}
}
//输出二叉树
void DispBTree(BTNode *b)
{
if(b!=NULL)
{
printf("%c",b->data);
if(b->lchild!=NULL||b->rchild!=NULL)
{
printf("(");
DispBTree(b->lchild);
if(b->rchild!=NULL)
printf(",");
DispBTree(b->rchild);
printf(")");
}
}
}
int main()
{
BTNode *b,*p,*lp,*rp;;
printf(" (1)创建二叉树.");
CreateBTree(b,"A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))");
printf("\n");
printf(" (2)输出二叉树:");
DispBTree(b);
printf("\n");
printf(" (3)查找H节点:");
p=FindNode(b,'H');
if (p!=NULL)
{
lp=LchildNode(p);
if (lp!=NULL)
printf("左孩子为%c,",lp->data);
else
printf("无左孩子 ");
rp=RchildNode(p);
if (rp!=NULL)
printf("右孩子为%c",rp->data);
else
printf("无右孩子 ");
}
else
printf(" 未找到！");
printf("\n");
printf(" (4)二叉树b的高度为:%d\n",BTHeight(b));
printf(" (5)释放二叉树b\n");
DestroyBTree(b);
return 0;
}
结果截图：
4、
#include <iostream>
#include <malloc.h>
using namespace std;
#define MaxSize 50
typedef char ElemType;
//递归声明
typedef struct node
{
char data;
struct node *lchild;
struct node *rchild;
}BTNode;
//非递归声明
typedef struct
{
BTNode *data[MaxSize];
int top;
}SqStack;
//层次遍历声明
typedef struct
{
BTNode *data[MaxSize];
int front,rear;
}SqQueue;
//递归算法
//创建二叉树
void CreateBTree(BTNode *&b,const 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 DispBTree(BTNode *b)
{
if(b!=NULL)
{
printf("%c",b->data);
if(b->lchild!=NULL||b->rchild!=NULL)
{
printf("(");
DispBTree(b->lchild);
if(b->rchild!=NULL)
printf(",");
DispBTree(b->rchild);
printf(")");
}
}
}
//先序遍历
void PreOrder(BTNode *b)
{
if(b!=NULL)
{
printf("%c ",b->data);
PreOrder(b->lchild);
PreOrder(b->rchild);
}
}
//中序遍历
void InOrder(BTNode *b)
{
if(b!=NULL)
{
InOrder(b->lchild);
printf("%c ",b->data);
InOrder(b->rchild);
}
}
//后序遍历
void PostOrder(BTNode *b)
{
if(b!=NULL)
{
PostOrder(b->lchild);
PostOrder(b->rchild);
printf("%c ",b->data);
}
}
//非递归算法
//先序遍历
void PreOrder1(BTNode *b)
{
BTNode *p;
SqStack *st;
InitStack(st);
if(b!=NULL)
{
Push(st,b);
while(!StackEmpty(st))
{
Pop(st,p);
printf("%c ",p->data);
if(p->rchild!=NULL)
Push(st,p->rchild);
if(p->lchild!=NULL)
Push(st,p->lchild);
}
printf("\n");
}
DestroyStack(st);
}
//中序遍历
void InOrder1(BTNode *b)
{
BTNode *p;
SqStack *st;
InitStack(st);
p=b;
while(!StackEmpty(st)||p!=NULL)
{
while(p!=NULL)
{
Push(st,p);
p=p->lchild;
}
if(!StackEmpty(st))
{
Pop(st,p);
printf("%c ",p->data);
p=p->rchild;
}
}
printf("\n");
DestroyStack(st);
}
//后序遍历
void PostOrder1(BTNode *b)
{
BTNode *p,*r;
bool flag;
SqStack *st;
InitStack(st);
p=b;
do
{
while(p!=NULL)
{
Push(st,p);
p=p->lchild;
}
r=NULL;
flag=true;
while(!StackEmpty(st)&&flag)
{
GetTop(st,p);
if(p->rchild==r)
{
printf("%c ",p->data);
Pop(st,p);
r=p;
}
else
{
p=p->rchild;
flag=false;
}
}
}while(!StackEmpty(st));
printf("\n");
DestroyStack(st);
}
//层次遍历
void LevelOrder(BTNode *b)
{
BTNode *b;
SqQueue *qu;
InitQueue(qu);
enQueue(qu,b);
while(!QueueEmpty(qu))
{
deQueue(qu,p);
printf("%c ",p->data);
if(p->lchild!=NULL)
enQueue(qu,p->lchild);
if(p->rchild!=NULL)
enQueue(qu,p->rchild);
}
}
int main()
{
BTNode *b;
CreateBTree(b,"A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))");
cout<<"二叉树为："<<endl;
DispBTree(b);
cout<<endl;
cout << "(1)递归算法:"<<endl;
cout << "先序遍历结果为:";
PreOrder(b);
cout << endl;
cout << "中序遍历结果为:";
InOrder(b);
cout << endl;
cout << "后序遍历结果为:";
PostOrder(b);
cout << endl;
cout << "(2)非递归算法:"<<endl;
cout << "先序遍历结果为:";
PreOrder(b);
cout << endl;
cout << "中序遍历结果为:";
InOrder(b);
cout << endl;
cout << "后序遍历结果为:";
PostOrder(b);
cout << endl;
cout << "(3)层次遍历结果为:";
LevelOrder(b);
return 0;
}
结果截图：
5、
#include<iomanip>
#include<stdio.h>
#include<malloc.h>
#define MaxSize 100
#define MaxWidth 40
typedef char ElemType;
typedef struct node
{
ElemType data;//数据元素
struct node *lchild;//指向左孩子
struct node *rchild;//指向右孩子
}BTNode;
//输出二叉树
void DispBTNode(BTNode *b)
{
if(b!=NULL)
{
printf("%c",b->data);
if(b->lchild!=NULL||b->rchild!=NULL)
{
printf("(");
DispBTNode(b->lchild);
if(b->rchild!=NULL)
printf(",");
DispBTNode(b->rchild);
printf(")");
}
}
}
//销毁二叉树
void DestroyBTNode(BTNode *&b)
{
if(b!=NULL)
{
DestroyBTNode(b->lchild);
DestroyBTNode(b->rchild);
free(b);
}
}
BTNode *CreateBT1(char *pre,char *in,int n)
{
BTNode *s;
char *p;
int k;
if (n<=0) return NULL;
s=(BTNode *)malloc(sizeof(BTNode));//创建二叉树节点*s
s->data=*pre;
for (p=in;p<in+n;p++)//在中序序列中找等于*ppos的位置k
if (*p==*pre) break;
k=p-in;
s->lchild=CreateBT1(pre+1,in,k);
s->rchild=CreateBT1(pre+k+1,p+1,n-k-1);
return s;
}
BTNode *CreateBT2(char *post,char *in,int n,int m)
{
BTNode *s;
char *p,*q,*maxp;
int maxpost,maxin,k;
if (n<=0) return NULL;
maxpost=-1;
for (p=in;p<in+n;p++)//求in中全部字符中在post中最右边的那个字符
for (q=post;q<post+m;q++)//在in中用maxp指向这个字符,用maxin标识它在in中的下标
if (*p==*q)
{
k=q-post;
if (k>maxpost)
{
maxpost=k;
maxp=p;
maxin=p-in;
}
}
s=(BTNode *)malloc(sizeof(BTNode));//创建二叉树节点*s
s->data=post[maxpost];
s->lchild=CreateBT2(post,in,maxin,m);
s->rchild=CreateBT2(post,maxp+1,n-maxin-1,m);
return s;
}
void DispBTNode1(BTNode *b)//以凹入表表示法输出一棵二叉树
{
BTNode *St[MaxSize],*p;
int level[MaxSize][2],top=-1,n,i,width=4;
char type;
if (b!=NULL)
{
top++;
St[top]=b;//根节点入栈
level[top][0]=width;
level[top][1]=2;//2表示是根
while (top>-1)
{
p=St[top];//退栈并凹入显示该节点值
n=level[top][0];
switch(level[top][1])
{
case 0:type='L';break;//左节点之后输出(L)
case 1:type='R';break;//右节点之后输出(R)
case 2:type='B';break;//根节点之后前输出(B)
}
for (i=1;i<=n;i++)//其中n为显示场宽,字符以右对齐显示
printf("");
printf("%c(%c)",p->data,type);
for (i=n+1;i<=MaxWidth;i+=2)
printf("--");
printf("\n");
top--;
if (p->rchild!=NULL)
{//将右子树根节点入栈
top++;
St[top]=p->rchild;
level[top][0]=n+width;//显示场宽增width
level[top][1]=1;//1表示是右子树
}
if (p->lchild!=NULL)
{//将左子树根节点入栈
top++;
St[top]=p->lchild;
level[top][0]=n+width;//显示场宽增width
level[top][1]=0;//0表示是左子树
}
}
}
}
int main()
{
BTNode *b;
ElemType pre[]="ABDEHJKLMNCFGI";
ElemType in[]="DBJHLKMNEAFCGI";
ElemType post[]="DJLNMKHEBFIGCA";
b=CreateBT1(pre,in,14);
printf("先序序列:%s\n",pre);
printf("中序序列:%s\n",in);
printf("构造一棵二叉树b:\n");
printf(" 括号表示法:");
DispBTNode(b);
printf("\n");
printf(" 凹入表示法:\n");
DispBTNode1(b);printf("\n\n");
printf("中序序列:%s\n",in);
printf("后序序列:%s\n",post);
b=CreateBT2(post,in,14,14);
printf("构造一棵二叉树b:\n");
printf(" 括号表示法:");
DispBTNode(b);
printf("\n");
printf(" 凹入表示法:\n");
DispBTNode1(b);
printf("\n");
DestroyBTNode(b);
}
结果截图：
6、
#include <iostream>
#include <malloc.h>
using namespace std;
#define MaxSize 50
typedef char ElemType;
//递归声明
typedef struct node
{
char data;
struct node *lchild;
struct node *rchild;
}BTNode;
//创建二叉树
void CreateBTree(BTNode *&b,const 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 DispBTree(BTNode *b)
{
if(b!=NULL)
{
printf("%c",b->data);
if(b->lchild!=NULL||b->rchild!=NULL)
{
printf("(");
DispBTree(b->lchild);
if(b->rchild!=NULL)
printf(",");
DispBTree(b->rchild);
printf(")");
}
}
}
//先序遍历
void PreOrder(BTNode *b)
{
if(b!=NULL)
{
printf("%c ",b->data);
PreOrder(b->lchild);
PreOrder(b->rchild);
}
}
//中序遍历
void InOrder(BTNode *b)
{
if(b!=NULL)
{
InOrder(b->lchild);
printf("%c ",b->data);
InOrder(b->rchild);
}
}
//后序遍历
void PostOrder(BTNode *b)
{
if(b!=NULL)
{
PostOrder(b->lchild);
PostOrder(b->rchild);
printf("%c ",b->data);
}
}
//结点个数
int Nodes(BTNode *b)
{
int num1,num2;
if(b==NULL)
return 0;
else
return Nodes(b->lchild)+Nodes(b->rchild)+1;
}
//叶子结点个数
int LeafNodes(BTNode *b)
{
if(!b)
return 0; //空树,无叶子
else if(!b->lchild && !b->rchild)
return 1;
else
return (LeafNodes(b->lchild) + LeafNodes(b->rchild));
}
//求指定结点值所在层次（假设二叉树结点互不相同）
int Level(BTNode *b,ElemType x,int h) //h置初值1
{ 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(l);
else //在左子树中未找到,再在右子树中查找
return(Level(b->rchild,x,h+1));
}
}
//利用层次遍历求二叉树的宽度
void traverse(BTNode b)
{
queue<BTNode> q;
BTNode p=NULL;
if(b)
q.push(Tb);
while(!q.empty())
{
p=q.front();
q.pop();
cout<<p->data<<" ";
if(p->lchild)
{
q.push(p->lchild);
}
if(p->rchild)
{
q.push(p->rchild);
}
}
}
int Width(BTNode *b)
{
if(b!=NULL)
{
if(b->lchild==NULL&&b->rchild==NULL)
return 1;
else
return Width(b->lchild)+Width(b->rchild);
}
}
int main()
{
BTNode *b;
int h;
ElemType x;
CreateBTree(b,"A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))");
cout<<"(1)结点个数："<<Nodes(b)<<endl;
cout<<"(2)叶子结点个数："<<LeafNodes(b)<<endl;
printf("(3)结点值:");
scanf("%c",&x);
h=Level(b,x,1);
if (h==0)
printf("b中不存在%c节点\n",x);
else
printf(" 在b中%c节点的层次为:%d\n",x,h);
cout<<"(4)二叉树b的宽 度为："<<(b);
结果截图：
3568
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
