二叉树的递归与非递归遍历

/*
二叉树的递归遍历与非递归遍历
*/

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

struct BiTreeNode{
    int value;
    BiTreeNode *left;
    BiTreeNode *right;
    BiTreeNode(int data){
        this->value = data; 
    }
};

//recursive
void preOrderRecur(BiTreeNode *head){
    if(head == NULL)
        return;
    cout<<head->value<<" ";
    preOrderRecur(head->left);
    preOrderRecur(head->right);
}

//recursive
void inOrderRecur(BiTreeNode *head){
    if(head == NULL)
        return;
    inOrderRecur(head->left);
    cout<<head->value<<" ";
    inOrderRecur(head->right);
}

//recursive
void postOrderRecur(BiTreeNode *head){
    if(head == NULL)
        return;
    postOrderRecur(head->left);
    postOrderRecur(head->right);
    cout<<head->value<<" ";
}

//unrecursive
//先序遍历：当前节点弹出时，打印，先压右孩子再压左孩子入栈
void preOrderUnrecur(BiTreeNode *head){
    if(head != NULL){
        stack<BiTreeNode*>s;
        s.push(head);
        while(!s.empty()){
            head = s.top();//取栈顶元素
            cout<<head->value<<" ";
            s.pop();//弹出栈顶
            if(head->right!=NULL)
                s.push(head->right);
            if(head->left!=NULL)
                s.push(head->left);
        }
    }   
}

//unrecursive
//中序遍历：对于当前节点，若为空，从栈中拿一个，打印，当前向右；若不为空，压入栈，当前向左
void inOrderUnrecur(BiTreeNode *head){
    if(head != NULL){
        stack<BiTreeNode*>s;
        while(!s.empty() || head != NULL){
            if(head != NULL){
                s.push(head);
                head = head -> left;
            }
            else{
                head = s.top();
                cout<<head->value<<" ";
                s.pop();
                head = head -> right;
            }
        }
    }   
}

//unrecursive
//后序遍历:基于先序遍历(中左右)，后序遍历先将左孩子入栈，再将右孩子入栈，即为中右左；再设定辅助栈s2，打印结果，即为左右中(后序遍历)
void postOrderUnrecur(BiTreeNode *head){
    if(head != NULL){
        stack<BiTreeNode*>s1;
        stack<BiTreeNode*>s2;
        s1.push(head);
        while(!s1.empty()){
            head = s1.top();//取栈顶元素
            s2.push(head);
            s1.pop();//弹出栈顶
            if(head->left!=NULL)
                s1.push(head->left);
            if(head->right!=NULL)
                s1.push(head->right);
        }
        while(!s2.empty()){
            cout<<s2.top()->value<<" ";
            s2.pop();
        }
    }   
}


int main()
{
    BiTreeNode *head = new BiTreeNode(5);
    head->left = new BiTreeNode(3);
    head->right = new BiTreeNode(8);
    head->left->left = new BiTreeNode(2);
    head->left->left->right = NULL;
    head->left->right = new BiTreeNode(4);
    head->left->right->left = NULL;
    head->left->right->right = NULL;
    head->left->left->left = new BiTreeNode(1);
    head->left->left->left->left = NULL;
    head->left->left->left->right = NULL;
    head->right->left = new BiTreeNode(7);
    head->right->left->right = NULL;
    head->right->left->left = new BiTreeNode(6);
    head->right->left->left->left = NULL; 
    head->right->left->left->right = NULL;
    head->right->right = new BiTreeNode(10);
    head->right->right->left = new BiTreeNode(9);
    head->right->right->left->left = NULL;
    head->right->right->left->right = NULL;
    head->right->right->right = new BiTreeNode(11);
    head->right->right->right->left = NULL;
    head->right->right->right->right = NULL;

    //recursive
    cout<<"==============recursive====================="<<endl;
    cout<<"pre-order:"<<endl;
    preOrderRecur(head);
    cout<<endl;
    cout<<"in-order:"<<endl;
    inOrderRecur(head);
    cout<<endl;
    cout<<"post-order:"<<endl;
    postOrderRecur(head);
    cout<<endl;

    //unrecursive
    cout<<"==============unrecursive===================="<<endl;
    cout<<"pre-order:"<<endl;
    preOrderUnrecur(head);
    cout<<endl;
    cout<<"in-order:"<<endl;
    inOrderUnrecur(head);
    cout<<endl;
    cout<<"post-order:"<<endl;
    postOrderUnrecur(head);
    cout<<endl;

    return 0;
}