二叉树（建立与访问）（先序，中序，后序）

二叉树的建立（先序建立）

二叉树的访问（递归与非递归 先序）（递归与非递归中序）（递归与非递归 后序）

#include<iostream>
#include<stack>
using namespace std;

struct Tree_Node ///结点的结构
{
    char data; ///每个结点的数据
    Tree_Node * left; ///左子树
    Tree_Node * right; ///右孩子
};
///按照先序遍历的方式，构建我们的二叉树,输入的时候，
///我们要按照完全二叉树的形式输入，结点为空的位置，输入“#”
void createTree(Tree_Node *&t)
{
    char str;
    cin>>str;
    if(str=='#')
    {
        t=NULL;
    }
    else
    {
        t=new Tree_Node; ///为t开辟空间
        t->data = str;
        createTree(t->left);
        createTree(t->right);
    }
}
void PreorderTraverse(Tree_Node * T)///先序遍历，递归实现
{
    if(T)
    {
        if(T->data!='#') cout<<T->data<<" ";   ///访问根结点
        PreorderTraverse(T->left);  ///访问左子树
        PreorderTraverse(T->right);  ///访问右子树
    }
}
///非递归实现,思路：
///首先我们的循环条件是：结点不为空或者栈不为空。
///然后是先把根结点加入桟中，然后，遍历左子树，当左子树遍历完后，栈顶元素为刚刚的根结点，
///然后，让根结点出栈，遍历右子树
void PreorderTraverse_no_recursive(Tree_Node * T)
{
    stack<Tree_Node*> s;
    Tree_Node *p = T; ///栈不为空或者T不为空时，循环继续
    while(p || !s.empty())
    {
        if(p!=NULL)
        {
            s.push(p); ///根结点入栈
            if(p->data!='#')///访问根结点
            cout<<p->data<<' ';
            p = p->left; ///先遍历左子树
        }
        else
        {
            p = s.top(); ///根结点出栈
            s.pop();
            p = p->right;///遍历右子树
        }
    }
}
void InorderTraverse(Tree_Node * T)///递归实现中序遍历
{
    if(T)
    {
        InorderTraverse(T->left); ///中序遍历左孩子
        if(T->data!='#') cout<<T->data<<" ";       ///访问根结点
        InorderTraverse(T->right); ///中序遍历右孩子
    }
}
///非递归实现中序遍历，思路：
///思路：T是要遍历树的根指针，中序遍历要求在遍历完左子树后，访问根，再遍历右子树。
///先将T入栈，遍历左子树；遍历完左子树返回时，栈顶元素应为T，出栈，访问T->data，
///再中序遍历T的右子树。
void InorderTraverse_recursive(Tree_Node * T)
{
    stack<Tree_Node*> s;
    Tree_Node * p=T;   ///栈不为空或者T不为空时，循环继续
    while(p || !s.empty())
    {
        if(p!=NULL)
        {
            s.push(p); ///根结点入栈
            p = p->left; ///先遍历左子树
        }
        else
        {
            p=s.top(); ///根结点出栈
            s.pop();
            if(p->data!='#') cout<<p->data<<' ';///访问根结点
            p = p->right;///遍历右子树
        }
    }
}
void PostorderTraverse(Tree_Node * T)///递归实现后序遍历
{
    if(T)
    {
        PostorderTraverse(T->left); ///访问左子树
        PostorderTraverse(T->right); ///访问右子树
        if(T->data!='#') cout<<T->data<<" "; ///访问根结点
    }
}
///非递归实现后序遍历
///思路：我们要保证根结点在左孩子和右孩子访问之后才能访问，因此对于任一结点P，先将其入栈。
///如果P不存在左孩子和右孩子，则可以直接访问它；
///或者P存在左孩子或者右孩子，但是其左孩子和右孩子都已被访问过了，则同样可以直接访问该结点。
///若非上述两种情况，则将P的右孩子和左孩子依次入栈，这样就保证了每次取栈顶元素的时候，
///左孩子在右孩子前面被访问，左孩子和右孩子都在根结点前面被访问。
void PostorderTraverse_recursive(Tree_Node * T)
{
    Tree_Node *pre; ///前一个被访问的结点。
    pre=NULL;
    stack<Tree_Node*> s;
    Tree_Node *cur;  ///记录栈顶的结点，
    s.push(T); ///先把根结点入栈
    while(!s.empty())
    {
        cur=s.top(); ///cur记录的是栈顶的结点
        if((cur->left==NULL && cur->right==NULL) || (pre!=NULL && (pre==cur->left || pre==cur->right)))
        {
            cout<<cur->data<<" "; ///满足：不存在左孩子和右孩子；或者存在左孩子或者右孩子，但是其左孩子和右孩子都已被访问过了
            s.pop();
            pre=cur; ///更新pre的值
        }
        else
        {
            if(cur->right!=NULL) s.push(cur->right); ///一定是右子树先入栈的，因为这样才可以比左子树后被访问
            if(cur->left!=NULL)s.push(cur->left); ///左子树入栈

        }
    }
}
int main()
{
    Tree_Node * T;
    createTree(T);
    cout<<"先序遍历--递归实现"<<endl;
    PreorderTraverse(T);
    cout<<endl;
    cout<<"先序遍历--非递归实现"<<endl;
    PreorderTraverse_no_recursive(T);
    cout<<endl;
    cout<<"中序遍历--递归实现"<<endl;
    InorderTraverse(T);
    cout<<endl;
    cout<<"中序遍历--非递归实现"<<endl;
    InorderTraverse_recursive(T);
    cout<<endl;
    cout<<"后序遍历--递归实现"<<endl;
    PostorderTraverse(T);
    cout<<endl;
    cout<<"后序遍历--非递归实现"<<endl;
    PostorderTraverse_recursive(T);
    cout<<endl;
    return 0;
}