二叉树的建立和遍历(递归建树&层序遍历建树)

#include<stdio.h>
#include <cstdlib>
#include <iostream>
#include <stack>
#include<queue>
using namespace std;

//二叉树定义
typedef char ElementType;
typedef struct Node *Position;
typedef Position BinTree;
struct Node
{
ElementType data;
BinTree Left;
BinTree Right;
} BiTreeNode, *BiTree;

//递归的建立一棵二叉树
//输入为二叉树的先序序列
void CreateBinTree(BinTree &T)
{
ElementType data;
data = getchar();
if(data == ‘#‘)
T = NULL;
else
{
T = new Node;
T->data = data;
CreateBinTree(T->Left);
CreateBinTree(T->Right);
}
}
void CreatBinTree_2(BinTree &rt,int n)///层序遍历建树
{
char root[2];
scanf("%s",root);
rt=new Node;
rt->data=root[0];
for(int i=2; i<=n; i++)
{
BinTree T=rt;
char tmp[2];
int num=0,a[16];
scanf("%s",tmp);
int ii=i;
while(ii)
{
a[num++]=ii%2;
ii/=2;
}
BinTree node=new Node;
node->data=tmp[0];
node->Right=NULL;
node->Left=NULL;
for(int j=num-2; j>0; j--)
if(a[j])T=T->Right;
else T=T->Left;
if(a[0])T->Right=node;
else T->Left=node;
}
}
int Nodenum(BinTree root)//二叉树节点数目
{
if(root == NULL) return 0;
else return 1+Nodenum(root->Left)+Nodenum(root->Right);
}
//递归销毁一棵二叉树
void destroyBinTree(BinTree &T)
{
if(T)
{
destroyBinTree(T->Left);
destroyBinTree(T->Right);
delete T;
T = NULL;
}
}

//递归先序遍历二叉树
void preOrderTraverse(const BinTree &T)
{
if(T)
{
// cout<<T->data<<" ";//输出根节点值
printf("%c ",T->data);
preOrderTraverse(T->Left);//遍历左子树
preOrderTraverse(T->Right);//遍历右子树
}
}

//递归中序遍历二叉树
void inOrderTraverse(const BinTree &T)
{
if(T)
{
inOrderTraverse(T->Left);//遍历左子树
// cout<<T->data<<" ";//输出根节点值
printf("%c ",T->data);
inOrderTraverse(T->Right);//遍历右子树
}
}

//递归后序遍历二叉树
void postOrderTraverse(const BinTree &T)
{
if(T)
{
postOrderTraverse(T->Left);//遍历左子树
postOrderTraverse(T->Right);//遍历右子树
printf("%c ",T->data);
// cout<<T->data<<" ";//输出根节点值
}
}

//递归求树的深度
int depthOfBinTree(const BinTree &T)
{
int ldepth;
int rdepth;

if(T==NULL)//空树
return 0;
ldepth = depthOfBinTree(T->Left);
rdepth = depthOfBinTree(T->Right);

return (ldepth>rdepth)?(ldepth+1):(rdepth+1);
}

//递归求二叉树的叶子结点个数
int leafCountOfBinTree(const BinTree &T)
{
if(T==NULL)
return 0;
if(T->Left==NULL && T->Right==NULL)
return 1;
return leafCountOfBinTree(T->Left) + leafCountOfBinTree(T->Right);
}

void exchangeChild(BinTree &T)///交换左右子树
{
if(T)
{
BinTree temp = NULL;

if(T->Left ||T->Right)
{
temp = T->Left;
T->Left = T->Right;
T->Right = temp;
exchangeChild(T->Left);
exchangeChild(T->Right);
}
}
}
void LevelOrderTraverse(BinTree T)///层序遍历
{
//Visit是对节点操作的应用函数,
//在这里,对每个数据元素调用函数Visit,也即是遍历了该节点
queue<BinTree>q;
BinTree p;
if(T)
{
q.push(T);
while(!q.empty())
{
p=q.front();
q.pop();
printf("%c ",p->data);
if(p->Left!=NULL) q.push(p->Left);
if(p->Right!=NULL) q.push(p->Right);
}
printf("\n");
}
}
int main()
{
BinTree T = NULL;

CreateBinTree(T);//建立二叉树 AB#D##CE###

printf("先序遍历: "); //先序遍历
preOrderTraverse(T);
printf("\n");

printf("中序遍历: ");//中序遍历
inOrderTraverse(T);
printf("\n");

printf("后序遍历: ");//后序遍历
postOrderTraverse(T);
printf("\n");

printf("层序遍历: ");
LevelOrderTraverse(T);

printf("交换左右子树: \n");
exchangeChild(T);

printf("先序遍历: "); //先序遍历
preOrderTraverse(T);
printf("\n");

printf("中序遍历: ");//中序遍历
inOrderTraverse(T);
printf("\n");

printf("后序遍历: ");//后序遍历
postOrderTraverse(T);
printf("\n");

printf("层序遍历: ");
LevelOrderTraverse(T);

printf("深度: %d\n",depthOfBinTree(T));//树的高度

printf("叶子结点数: %d\n",leafCountOfBinTree(T));//叶子结点数

printf("总结点数量: %d\n",Nodenum(T));
destroyBinTree(T);//销毁二叉树,释放空间

///================================================================

int n;
scanf("%d",&n);
BinTree TT=NULL;
CreatBinTree_2(TT,n);

printf("先序遍历: "); //先序遍历
preOrderTraverse(TT);
printf("\n");

printf("中序遍历: ");//中序遍历
inOrderTraverse(TT);
printf("\n");

printf("后序遍历: ");//后序遍历
postOrderTraverse(TT);
printf("\n");

printf("深度: %d\n",depthOfBinTree(TT));//树的高度

printf("叶子结点数: %d\n",leafCountOfBinTree(TT));//叶子结点数

printf("总结点数量: %d\n",Nodenum(TT));
destroyBinTree(TT);//销毁二叉树,释放空间
system("PAUSE");
return EXIT_SUCCESS;
}

原文地址:https://www.cnblogs.com/astonc/p/9906518.html

时间: 2024-10-09 20:58:21

二叉树的建立和遍历(递归建树&层序遍历建树)的相关文章

UVa 122 Trees on the level (动态建树 &amp;&amp; 层序遍历二叉树)

题意  :输入一棵二叉树,你的任务是按从上到下.从左到右的顺序输出各个结点的值.每个结 点都按照从根结点到它的移动序列给出(L表示左,R表示右).在输入中,每个结点的左 括号和右括号之间没有空格,相邻结点之间用一个空格隔开.每棵树的输入用一对空括 号"()"结束(这对括号本身不代表一个结点),注意,如果从根到某个叶结点的路径上有的结点没有在输入中给出,或者给出超过一 次,应当输出not complete.结点个数不超过256. 分析  : 如果使用数组建树的话,256个结点看着不多,但

c之二叉树链表操作---建立、(递归)前序遍历、中序遍历、后序遍历

[二叉树链表] 1.节点定义: typedef struct node{ int data; struct node*lchild,*rchild; }Tree,*BiTree; 2.创建二叉树: BiTree creat_Tree(BiTree root,int num){//建立二叉树 if(root==NULL) { root=(Tree *)malloc(sizeof(Tree)); if(root==NULL) { printf("no memory available\n"

二叉树的建立及其前中后序遍历

1 //二叉树存储结构: 2 struct node 3 { 4 Int data; 5 node *lchild; 6 node *rchild; 7 }; 8 9 //二叉树在建树前根节点不存在: 10 Node *root = NULL; 11 12 //新建结点: 13 node *newNode(int v) 14 { 15 node *Node = new node; 16 Node->data = v; 17 Node->lchild = NULL; 18 Node->rc

二叉树的建立,非递归前序、中序、后续遍历

算法网上很多,这里只是我手写的可执行的代码,备份用. #include <iostream> #include <vector> #include<queue> using namespace std; struct node {     char element; struct node * left; struct node * right; //struct node * parent; node (char a) { element = a; } }; stru

二叉树的遍历:先序中序后序遍历的递归与非递归实现及层序遍历

对于一种数据结构而言,遍历是常见操作.二叉树是一种基本的数据结构,是一种每个节点的儿子数目都不多于2的树.二叉树的节点声明如下: 1 typedef struct TreeNode *PtrToNode; 2 typedef struct TreeNode *BinTree; 3 4 struct TreeNode 5 { 6 int Data; //为简单起见,不妨假设树节点的元素为int型 7 BinTree Left; 8 BinTree Right; 9 }; 二叉树的遍历主要有先序遍历

二叉树的建立以及遍历的多种实现(python版)

二叉树是很重要的数据结构,在面试还是日常开发中都是很重要的角色. 首先是建立树的过程,对比C或是C++的实现来讲,其涉及到了较为复杂的指针操作,但是在面向对象的语言中,就不需要考虑指针, 内存等.首先我们需要定义一个树节点, 我们采用基于链表设计的节点, 首先定义一个数据域, 其次就是左孩子和右孩子.如下定义: # 树节点的定义 class Node: def __init__(self, data=-1, lchild=None, rchild=None): self.lchild = lch

二叉树的遍历--递归实现与非递归实现

二叉树的表示 在研究二叉树的遍历之前,我们需要先看看二叉树的表示方式. 一般来说,我们使用自定义的数据结构或是数组来表示二叉树. 二叉树的数据结构: public class TreeNode { public int val; // 左孩子 public TreeNode left; // 右孩子 public TreeNode right; } 数组形式表现二叉树 当我们使用数组形式表现二叉树时,我们将数组第一个节点的索引置为「1」,也就是根节点,如果我们通用性的将其当为「x」,那么它的左孩

二叉树的建立、三种(递归、非递归)遍历方法

二叉树定义: 1.有且仅有一个特定的称之为根root的结点 2.当n>1时,除根结点之外的其余结点分为两个互不相交的子集.他们称为二叉树的左子树和右子树. 二叉树的一种建立方法: 若对有n个结点的完全二叉树进行顺序编号(1<=i<=n),那么,对于编号为i(i>=1)的结点. 当i=1时,该结点为根,它无双亲结点; 当i>1时,该节点的双亲编号为[i/2]; 若2i<=n,该结点为编号为2i的左孩子,否则没有左孩子 当2i+1<=n,该结点有编号为2i+1的右孩子

二叉树的非递归遍历(先序、中序、后序和层序遍历)

[前文] 二叉树的非递归遍历有 先序遍历.中序遍历 .后续遍历 和 层序遍历. 非递归算法实现的基本思路:使用堆栈.而层序遍历的实现:使用队列. 如下图所示的二叉树: 前序遍历顺序为:ABCDE (先访问根节点,然后先序遍历其左子树,最后先序遍历其右子树) 中序遍历顺序为:CBDAE (先中序遍历其左子树,然后访问很节点,最后中序遍历其右子树) 后续遍历顺序为:CDBEA (先后序遍历其左子树,然后后续其右子树,最后访问根节点) 层序遍历顺序为:ABECD (由上至下.从左到右遍历二叉树) [准