二叉树的三种遍历六种实现

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

struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};

/**
    TreeNode* init_node(int value);
*/ 
TreeNode* init_node(){
    TreeNode* r0 = new TreeNode(0);
    TreeNode* r1 = new TreeNode(1);
    TreeNode* r2 = new TreeNode(2);
    TreeNode* r3 = new TreeNode(3);
    TreeNode* r4 = new TreeNode(4);
    TreeNode* r5 = new TreeNode(5);
    TreeNode* r6 = new TreeNode(6);
    r0->left = r1;r0->right = r2;
    r1->left = r3;r1->right = r4;
    r2->left = r5;r2->right = r6;
    r3->left=r3->right=r4->left=r4->right=r5->left=r5->right=r6->left=r6->right=NULL;
    return r0;
}
//前序遍历-递归实现 
void pre_order0(TreeNode* root){
    if(root == NULL)    return;
    cout<<root->val<<'\t';
    pre_order0( root->left);
    pre_order0( root->right);
}  
//前序遍历-非递归实现 
void pre_order(TreeNode* root){
    if(root == NULL) return; 
    stack<TreeNode*> nodes;
    TreeNode* tmp = root;
    while(tmp != NULL){
        cout<< tmp->val<<'\t';
        if(tmp->right) nodes.push(tmp->right);
        if(tmp->left) nodes.push(tmp->left);
        if(nodes.empty())   break;
        tmp = nodes.top();
        nodes.pop();
    }
} 

//中序遍历-递归实现 
void in_order(TreeNode* root){
    if(root == NULL)    return;
    in_order( root->left);
    cout<<root->val<<'\t';
    in_order(root->right);
} 
//中序遍历-非递归实现
void in_order_0(TreeNode* root){
    stack<TreeNode*> nodes;
    TreeNode* tmp = root;
    while(!nodes.empty() || tmp){
        if(tmp){
            nodes.push(tmp);
            tmp = tmp->left; 
        }else{
            tmp = nodes.top();
            cout<<tmp->val<<'\t';
            nodes.pop();
            tmp = tmp->right; 
        }
    }
}

//后序遍历-递归实现
void post_order(TreeNode* root){
    if(root == NULL)    return;
    post_order(root->left);
    post_order(root->right);    
    cout<<root->val<<'\t';
} 
//后序遍历-非递归实现
void post_order0(TreeNode* root){
    stack<TreeNode*> s;
    TreeNode* h = root;
    if(root == NULL)
        return;
    s.push(root);
    while(!s.empty()){
       TreeNode* cur = s.top();
        if(cur->left != NULL && h != cur->left &&　h != cur->right)
            s.push(cur->left);
        else if(cur->right != NULL && h != cur->right){
            s.push(cur->right);
        }else{
            cout<<cur->val<<'\t';
            s.pop();
            h = cur;
        }
    }
}

int main(){

    TreeNode* root = init_node();
    in_order_0(root);
    return 0;
}