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

二叉树问题：

#include <iostream>
#include <vector>
#include <string>
#include <sstream>
#include<stack>
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;
 else{ 
  T=new BiTreeNode;//产生新的子树 
  T->data=ch;
  CreateBiTree(T->left_child,array);//递归创建左子树 
  CreateBiTree(T->right_child,array);//递归创建右子树 
 } 
}//CreateTree 
// 递归 先序遍历
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;
        }
    }
    }
}

int main(){
char array[]= "abce***d**mn*k**o*jh***";
BiTreeNode*T;
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;

return 0;
}