第十周项目3---二叉树遍历的应用

来源：互联网发布：基于java电商系统源码编辑：程序博客网时间：2024/06/06 00:39

/*问题及代码
*Copyright(c)2015,烟台大学计算机学院
*All right reserved.
*文件名称：二叉树遍历的算法应用 .cpp
*作者：邹晓琳
*完成日期；2016年10月29日
*版本号；v1.0
*问题描述：（1）计算二叉树节点个数；
　　（2）输出所有叶子节点；
　　（3）求二叉树b的叶子节点个数
　　（4）设计一个算法Level(b,x,h)，返回二叉链b中data值为x的节点的层数。

*输入描述：输入二叉树的各个节点值
*程序输出：根据要求输出

1.main.cpp

#include <stdio.h>
#include "btree.h"

int main()
{
BTNode *b;
CreateBTNode(b,"A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))");
printf("二叉树节点个数: %d\n", Nodes(b));
printf("二叉树中所有的叶子节点是: ");
DispLeaf(b);
printf("\n");
printf("二叉树b的叶子节点个数: %d\n",LeafNodes(b));
printf("值为\'K\'的节点在二叉树中出现在第 %d 层上",Level(b,'K',1));


DestroyBTNode(b);
return 0;
}

2.btree.h

#ifndef BTREE_H_INCLUDED
#define BTREE_H_INCLUDED
#define MaxSize 100
typedef char ElemType;
typedef struct node
{
ElemType data; //数据元素
struct node *lchild; //指向左孩子
struct node *rchild; //指向右孩子
} BTNode;
void CreateBTNode(BTNode *&b,char *str); //由str串创建二叉链
BTNode *FindNode(BTNode *b,ElemType x); //返回data域为x的节点指针
BTNode *LchildNode(BTNode *p); //返回*p节点的左孩子节点指针
BTNode *RchildNode(BTNode *p); //返回*p节点的右孩子节点指针
int BTNodeDepth(BTNode *b); //求二叉树b的深度
void DispBTNode(BTNode *b); //以括号表示法输出二叉树
void DestroyBTNode(BTNode *&b); //销毁二叉树
void PostOrder(BTNode *b); //后序遍历的递归算法
void InOrder(BTNode *b); //中序遍历的递归算法
void PreOrder(BTNode *b); //先序遍历的递归算法
int Like(BTNode *b1,BTNode *b2);
int Level(BTNode *b,ElemType x,int h);
int LeafNodes(BTNode *b);
void DispLeaf(BTNode *b);
int Nodes(BTNode *b);

#endif // BTREE_H_INCLUDED

3.btree.cpp

#include <stdio.h>
#include <malloc.h>
#include "btree.h"
int Nodes(BTNode *b)
{
if (b==NULL)
return 0;
else
return Nodes(b->lchild)+Nodes(b->rchild)+1;
}
void DispLeaf(BTNode *b)
{
if (b!=NULL)
{
if (b->lchild==NULL && b->rchild==NULL)
printf("%c ",b->data);
else
{
DispLeaf(b->lchild);
DispLeaf(b->rchild);
}
}
}
int LeafNodes(BTNode *b) //求二叉树b的叶子节点个数
{
int num1,num2;
if (b==NULL)
return 0;
else if (b->lchild==NULL && b->rchild==NULL)
return 1;
else
{
num1=LeafNodes(b->lchild);
num2=LeafNodes(b->rchild);
return (num1+num2);
}
}

int Level(BTNode *b,ElemType 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 Like(BTNode *b1,BTNode *b2)
{
int like1,like2;
if (b1==NULL && b2==NULL)
return 1;
else if (b1==NULL || b2==NULL)
return 0;
else
{
like1=Like(b1->lchild,b2->lchild);
like2=Like(b1->rchild,b2->rchild);
return (like1 & like2);
}
}









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 CreateBTNode(BTNode *&b,char *str) //由str串创建二叉链
{
BTNode *St[MaxSize],*p=NULL;
int top=-1,k,j=0;
char ch;
b=NULL; //建立的二叉树初始时为空
ch=str[j];
while (ch!='\0') //str未扫描完时循环
{
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) //p指向二叉树的根节点
b=p;
else //已建立二叉树根节点
{
switch(k)
{
case 1:
St[top]->lchild=p;
break;
case 2:
St[top]->rchild=p;
break;
}
}
}
j++;
ch=str[j];
}
}
BTNode *FindNode(BTNode *b,ElemType x) //返回data域为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) //返回*p节点的左孩子节点指针
{
return p->lchild;
}
BTNode *RchildNode(BTNode *p) //返回*p节点的右孩子节点指针
{
return p->rchild;
}
int BTNodeDepth(BTNode *b) //求二叉树b的深度
{
int lchilddep,rchilddep;
if (b==NULL)
return(0); //空树的高度为0
else
{
lchilddep=BTNodeDepth(b->lchild); //求左子树的高度为lchilddep
rchilddep=BTNodeDepth(b->rchild); //求右子树的高度为rchilddep
return (lchilddep>rchilddep)? (lchilddep+1):(rchilddep+1);
}
}
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);
}
}

运行结果：

知识点总结

这个程序包含了这五个基本运算的前四个，比较复杂。

首先第一个问题是求二叉树节点的个数，即判断每个节点的左右孩子是否存在，然后进而进行计数。

第二个问题是求所有的叶子节点，即此节点无左右孩子即可输出。

第三个问题是直接计数叶子节点，不用输出就可以

第四个问题是查找某值的节点层数，个人觉得这个充分运用了层次遍历的特点，逐层筛选直到找到次值。

所有的基础算法都运用到了递归，其实根据一个函数把他递归循环的这些方式弄懂了其他的就不难了。

学习心得

二叉树节点个数的函数费了点劲，先是画图没大弄懂，感觉还是挺抽象，但是我觉得这东西除了画图还得靠在脑海里寻思寻思，寻思多了就容易开窍了。

顶
0
踩

0 0