二叉树，建树，前序，中序，后序，递归 非递归

二叉树遍历：

#include <iostream>
#include <vector>
#include <string>
#include <sstream>
#include<stack>
#include<queue>
using namespace std;
struct BiTreeNode {
    char data;
    struct BiTreeNode *left_child;
    struct BiTreeNode *right_child;
};

int N  = 0;


void CreateBiTree(BiTreeNode* &T,char array[]){ 
 //按先序输入二叉树中结点的值（一个字符），空格字符表明空树， 
 //构造二叉树表表示二叉树T。 
 char ch = array[N];
 N = N + 1; 
 if(ch =='*') T=NULL;//其中getchar（）为逐个读入标准库函数 
 else{ 
  T=new BiTreeNode;//产生新的子树 
  T->data=ch;//由getchar（）逐个读入来 
  CreateBiTree(T->left_child,array);//递归建立左子树 
  CreateBiTree(T->right_child,array);//递归建立右子树 
 } 
}//CreateTree 


void create_T(BiTreeNode* &T, char array[]) {
    char ch = array[N];
    N=N+1;
    if (ch == '*') {
        T = NULL;
    } else {
        T = new BiTreeNode;
        T->data = ch;
        create_T(T->left_child, array);
        create_T(T->right_child, array);
    }
}

// 递归 先序遍历
void pre_order_traverse(BiTreeNode* &T) {
    // 先序遍历
    if (T) {
        cout << T->data << " ";
        pre_order_traverse(T->left_child);
        pre_order_traverse(T->right_child);
    }
}

//先序遍历 非递归；
void pre_order_traverse_no_recurse(BiTreeNode* &T) {
    // 非递归先序遍历二叉树
    stack<BiTreeNode*> s;
    BiTreeNode *p = T;

    // 当栈非空或者p指针非空时调用循环
    while (p != nullptr || !s.empty()) {
        while ( p != nullptr) {
            cout << p->data << " ";
            s.push(p);
            p = p->left_child;
        }
        if (!s.empty()) {
            p = s.top();
            s.pop();
            p = p->right_child;
        }
    }
}

// 递归 中序遍历
void in_order_traverse(BiTreeNode* &T) {
    // 中序遍历
    if (T) {
        in_order_traverse(T->left_child);
        cout << T->data << " ";
        in_order_traverse(T->right_child);
    }
}

// 中序遍历 非递归
void in_order_traverse_no_recurse(BiTreeNode* &T) {
    stack<BiTreeNode*> s;
    BiTreeNode *p = T;

    while (p != nullptr || !s.empty()) {
        while ( p != nullptr) {
            s.push(p);
            p = p->left_child;
        }

        if (!s.empty()) {
            p = s.top();
            cout << p->data << " ";
            s.pop();
            p = p->right_child;
        }
    }
}

// 递归 后序遍历
void pos_order_traverse(BiTreeNode* &T) {
    // 中序遍历
    if (T) {
        pos_order_traverse(T->left_child);
        pos_order_traverse(T->right_child);
        cout << T->data << " ";
    }
}

// 后序遍历 非递归
void pos_order_traverse_no_recurse(BiTreeNode* &T) {
    stack<BiTreeNode*> s;
    BiTreeNode *p = T;
    BiTreeNode*pp = NULL;
    while (p != nullptr || !s.empty()) {
        while ( p != nullptr) {
            s.push(p);
            p = p->left_child;
        }
        if (!s.empty()) {
            p = s.top();
            if(p->right_child==NULL || p->right_child == pp){
            cout<<p->data<<" ";
            s.pop();
            pp = p;
            p = NULL;
        }
        else{
            p=p->right_child;
        }
    }
    }
}

void BFS(BiTreeNode* &T)
{
    queue<BiTreeNode*>s;
    BiTreeNode *p = T;

    s.push(T);
    while(!s.empty())
    {
        p = s.front();
        s.pop();
        cout<<p->data<<" ";
        if(p->left_child)
        {
            s.push(p->left_child);
        }
        if(p->right_child)
        {
            s.push(p->right_child);
        }
    }

}

int main(){
char array[]= "abce***d**mn*k**o*jh***";
BiTreeNode*T;
// create_T(T,array);

CreateBiTree(T,array);

//pre_order
cout<<"pre_order_traverse"<<endl;
pre_order_traverse(T);
cout<<endl;
cout<<"pre_order_traverse_no_recurse"<<endl;
pre_order_traverse_no_recurse(T);
cout<<endl;

//in_order
cout<<"in_order_traverse"<<endl;
in_order_traverse(T);
cout<<endl;
cout<<"in_order_traverse_no_recurse"<<endl;
in_order_traverse_no_recurse(T);
cout<<endl;

//pos_order
cout<<"pos_order_traverse"<<endl;
pos_order_traverse(T);
cout<<endl;
cout<<"pos_order_traverse_no_recurse"<<endl;
pos_order_traverse_no_recurse(T);
cout<<endl;

//层次遍历
BFS(T);

return 0;
}