二叉树的非递归遍历（前中后序）

/*
二叉树的非递归遍历
    先序 中序  后序
*/

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

typedef struct node{
    int value;
    struct node* left,*right;
}Tree;

/*使用递归（先序）创建二叉树*/
void Create(Tree* &root)
{
    int value ;
    cin>>value ;
    if(value == 0 )  return ;
    root = new Tree;
    root->left = NULL; root->value = value; root->right = NULL;
    Create(root->left);
    Create(root->right);

}
/*递归先序遍历*/
void Traver_x(Tree* root)
{
    if(root == NULL)  return ;
    cout<<root->value<<" ";
    Traver_x(root->left);
    Traver_x(root->right);
}
/*非递归先序遍历*/
void f_Traver_x(Tree* root)
{
    if (root == NULL)  return ;
    stack<Tree*> stack_tree;
    cout<<root->value<<" ";
    stack_tree.push(root);
    root = root->left;
    while(root){
        cout<<root->value<<" ";
        stack_tree.push(root);
        root= root->left;
    }
    Tree* node = NULL;
    while(!stack_tree.empty())
    {
        node = stack_tree.top();
        stack_tree.pop();
        if(node->right ){
            node = node->right;
            while(node){
                cout<<node->value<<" ";
                stack_tree.push(node);
                node = node->left;
            }
        }
    }
}
/*递归中序遍历*/
void Traver_z(Tree* root)
{
    if(root == NULL)  return ;
    Traver_z(root->left);
    cout<<root->value<<" ";
    Traver_z(root->right);
}
/*非递归中序遍历*/
void f_Traver_z(Tree* root)
{
    if(root == NULL)  return ;
    stack<Tree*> stack_tree;
    while(root){
        stack_tree.push(root);
        root = root->left;
    }
    Tree* node = NULL;
    while(!stack_tree.empty()){
        node = stack_tree.top();
        cout<< node->value<<" ";
        stack_tree.pop();
        if(node->right){
            node = node->right;
            while(node){
                stack_tree.push(node);
                node = node->left;
            }
        }
    }
}
/*后序递归遍历*/
void Traver_h(Tree* root)
{
    if(root == NULL)  return ;
    Traver_h(root->left);
    Traver_h(root->right);
    cout<<root->value<<" ";
}

/*非递归的后序遍历*/
void f_Traver_h(Tree *root)
{
    if(root == NULL)  return ;
    stack<Tree*>  stack_tree;
    int tag = 0;
    Tree* node = NULL;
    do{
        while(root){   /*所有的左节点入栈*/
            stack_tree.push(root);
            root = root->left;
        }
        tag = 1;  node = NULL;
        while(!stack_tree.empty() && tag ){
            root = stack_tree.top();
            if(root->right == node){     
                cout<<root->value<<" ";
                stack_tree.pop();
                node = root;
            }
            else{
                root = root->right;
                tag =0;
            }
        }
    }while(!stack_tree.empty());
}
int main()
{
    Tree* root = NULL;
    Create(root);
    cout<<"--------------------------递归先序遍历-----------------------------"<<endl;
    Traver_x(root);
    cout<<endl<<"--------------------------非递归先序遍历-----------------------------"<<endl;
    f_Traver_x(root);
    cout<<endl<<"--------------------------递归中序遍历-----------------------------"<<endl;
    Traver_z(root);
    cout<<endl<<"--------------------------非递归中序遍历-----------------------------"<<endl;
    f_Traver_z(root);
    cout<<endl<<"--------------------------递归后序遍历-----------------------------"<<endl;
    Traver_h(root);
    cout<<endl<<"--------------------------非递归后序遍历-----------------------------"<<endl;
    f_Traver_h(root);
    cout<<endl;
    system("pause");
    return 0;
}