c++实现二叉树层序、前序创建二叉树，递归非递归实现二叉树遍历

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

class Node{
public :
char data;
struct Node *lchild,*rchild;
};

class BiTree{
public:
Node * root;//头结点
int height=0;//树的高度
BiTree() {root=NULL;}
//层序创建二叉树
void create_level(string &s)
{
int p=0;
root=new Node();

Node *t,*i,*j;
queue<Node*> qTree;//定义一个队列，存储节点
while(true)
{
if(p==s.size())break;
if(p==0)//当头结点未创建
{
t=new Node();
t->data=s
;
qTree.push(t);//头结点进队
root=t;
p++;
}
else
{
t=qTree.front();//该节点出队
if(p==s.size())break;//树的构建完毕
if(s[p]=='#')//不存在左节点
{
t->lchild=NULL;
p++;
}
else//存在左节点
{
i=new Node();
i->data=s[p];
t->lchild=i;//左节点进队
qTree.push(i);
p++;
}

if(p==s.size())break;
if(s[p]=='#')//不存在右节点
{
t->rchild=NULL;
p++;
}
else//存在右节点
{
j=new Node();
j->data=s[p];
t->rchild=j;
qTree.push(j);
p++;
}

qTree.pop();//节点左右节点已创建，该节点出队
}
}

}
//前序递归创建二叉树
void create_pre(string s)
{
int p=-1;
root=create(s,p);
}
Node *create(string &s,int &p)
{
++p;
Node *t;
if((unsigned)p>=s.size())
{
return NULL;
}
else
{
if(s[p]=='#')
{
t=NULL;
}
else
{
t=new Node;
t->data=s[p];
t->lchild=create(s,p);
t->rchild=create(s,p);
}
return t;
}
}

//前序递归遍历二叉树
void read_pre_oder(Node *t)
{
if(t!=NULL)
{
cout<<t->data<<' ';
read_pre_oder(t->lchild);
read_pre_oder(t->rchild);
}
}
//中序递归遍历二叉树
void read_mid_oder(Node *t)
{
if(t!=NULL)
{
read_mid_oder(t->lchild);
cout<<t->data<<' ';
read_mid_oder(t->rchild);
}
}
//后续递归遍历二叉树
void read_beh_oder(Node *t)
{
if(t!=NULL)
{
read_beh_oder(t->lchild);
read_beh_oder(t->rchild);
cout<<t->data<<' ';
}
}

//利用栈实现前序遍历二叉树
void read_pre_oder_stack(Node *t)
{
if(t!=NULL)
{
stack<Node*> sTree;//声明一个栈存储节点
while(true)
{
if(sTree.size()==0&&t==NULL) break;
while(true)//一直遍历左节点，输出
{
if(t==NULL) break;//该节点不存在左节点，跳出循环
cout<<t->data<<' ';
sTree.push(t);//节点进栈，以便后期遍历右节点
t=t->lchild;
}
t=sTree.top();//查看该节点是否存在右子树
sTree.pop();//节点已遍历出栈
/*遍历该节点右子树，若不存在右子树，继续循环，
存在则进入内部while循环查找该右子树的左节点*/
t=t->rchild;

}
}
}
//利用栈实现中序遍历二叉树
void read_mid_oder_stack(Node *t)
{
if(t!=NULL)
{
stack<Node*> sTree;//声明一个栈存储节点
while(true)
{
if(sTree.size()==0&&t==NULL) break;
while(true)
{
if(t==NULL) break;
sTree.push(t);//一直存储左节点
t=t->lchild;
}
t=sTree.top();
cout<<t->data<<' ';//不存在左节点，输出该节点
sTree.pop();//该节点出栈
t=t->rchild;//查找该节点的右子树
}
}
}
//利用栈实现后序遍历二叉树
void read_beh_oder_stack(Node *t)
{
if(t!=NULL)
{
stack<Node*> sTree1;//该栈用于存储遍历过程的节点
stack<Node*> sTree2;//该栈用于存储遍历结果，输出
sTree1.push(t);//头节点进栈
while(true)
{
if (sTree1.size()==0) break;
t=sTree1.top();
sTree1.pop();
if(t->lchild!=NULL)//存在左节点，节点进栈
{
sTree1.push(t->lchild);
}
if(t->rchild!=NULL)//存在右节点，节点进栈
{
sTree1.push(t->rchild);
}
sTree2.push(t);//存储该节点（第一步开始存储的就是头节点，头结点存储在栈底）
}
while(true)//输出
{
if(sTree2.size()==0) break;
t=sTree2.top();
cout<<t->data<<' ';
sTree2.pop();
}
}
}
//利用栈、队列实现层序遍历
void read_lev_oder_stack(Node *t)
{
if(t!=NULL)
{
stack<Node*> sTree;
queue<Node*> qTree;
sTree.push(t);
qTree.push(t);
while(true)
{
if(sTree.size()==0)break;
t=sTree.top();
sTree.pop();
if(t->lchild!=NULL)
{
sTree.push(t->lchild);
qTree.push(t->lchild);
}
if(t->rchild!=NULL)
{
sTree.push(t->rchild);
qTree.push(t->rchild);
}
}
while(true)
{
if(qTree.size()==0) break;
t=qTree.front();
cout<<t->data<<' ';
qTree.pop();
}
}
}

//求树的高度
int tree_height(Node *t)
{
get_height(t,0);
return height;
}
void get_height(Node *t,int h)
{
if(t==NULL) return;
h++;
if(h>height)
{
height=h;
}
get_height(t->lchild,h);
get_height(t->rchild,h);
}
};

int main()
{
BiTree a;
string s;
s="ABD##E#F##C##";

//    a.create_level(s);
a.create_pre(s);

cout<<"递归实现前序遍历"<<endl;
a.read_pre_oder(a.root);
cout<<endl<<"递归实现中序遍历"<<endl;
a.read_mid_oder(a.root);
cout<<endl<<"递归实现后序遍历"<<endl;
a.read_beh_oder(a.root);
cout<<endl;

cout<<"栈实现前序遍历"<<endl;
a.read_pre_oder_stack(a.root);
cout<<endl<<"栈实现中序遍历"<<endl;
a.read_mid_oder_stack(a.root);
cout<<endl<<"栈实现后序遍历"<<endl;
a.read_beh_oder_stack(a.root);
cout<<endl<<"栈、队列实现层序遍历"<<endl;
a.read_lev_oder_stack(a.root);
cout<<endl<<"树的高度为： "<<endl;

int height=a.tree_height(a.root);
cout<<height<<endl;

return 0;
}