二叉树遍历

#include <iostream>
#include <algorithm>
#include <vector>
#include <stack>

using namespace std;

struct BiTNode{
    char data;
    struct BiTNode *lchild, *rchild; 
};

BiTNode *T;

void CreateBiTree(BiTNode * &T);
void printContent(vector<char>ans);
void PreOrderRecur(BiTNode * &T);
void PreOrderNoRecur(BiTNode * &T,vector<char>&ans);
void InOrderRecur(BiTNode * &T);
void InOrderNoRecur(BiTNode * &T, vector<char>&ans);
void PostOrderRecur(BiTNode * &T);
void PostOrderNoRecur(BiTNode * &T,vector<char>&ans);

int main(){
    
    cout << "用“#”代表空树" << endl;
    CreateBiTree(T);
    cout << "先序递归遍历" << endl;
    PreOrderRecur(T);
    cout << endl;
    cout << "中序递归遍历" << endl;
    InOrderRecur(T);
    cout << endl;
    cout << "后序递归遍历" << endl;
    PostOrderRecur(T);
    cout << endl;
    
    vector<char>ans_pre;
    vector<char>ans_in;
    vector<char>ans_post;

    cout << "前序非递归遍历" << endl;
    PreOrderNoRecur(T,ans_pre);
    printContent(ans_pre);

    cout << "中序非递归遍历" << endl;
    InOrderNoRecur(T,ans_in);
    printContent(ans_in);

    cout << "后序非递归遍历" << endl;
    PostOrderNoRecur(T,ans_post);
    printContent(ans_post);
    return 0;

}

//使用前序遍历创建二叉树
void CreateBiTree(BiTNode * &T){
    char ch;
    if((ch=getchar()) == '#')
        T = NULL;
    else{
        T = new BiTNode;
        T->data = ch;
        CreateBiTree(T->lchild);
        CreateBiTree(T->rchild);
    }

}

// 容器内容输出
void printContent(vector<char>ans){

    vector<char>::iterator iter;

    for(iter=ans.begin();iter!=ans.end();iter++){
        cout << *iter << " ";
    }
    cout << endl;

}

//前序遍历二叉树
void PreOrderRecur(BiTNode * &T){
    if(T){
        cout << T->data;
        PreOrderRecur(T->lchild);
        PreOrderRecur(T->rchild);
    }else{
        cout <<"";
    }

}

// 非递归前序遍历二叉树
void PreOrderNoRecur(BiTNode * &T, vector<char>&ans){
    stack <BiTNode *> stack;
    stack.push(T);
    BiTNode * node;
    while(!stack.empty()){

        node = stack.top();
        ans.push_back(node->data);
        stack.pop();

        if(node->rchild)
            stack.push(node->rchild);
        if(node->lchild)
            stack.push(node->lchild);
    }


}

//中序遍历二叉树
void InOrderRecur(BiTNode * &T){
    if(T){
        InOrderRecur(T->lchild);
        cout << T->data;
        InOrderRecur(T->rchild);

    }else{
        cout << "";
    }

}

//非递归中序遍历二叉树
void InOrderNoRecur(BiTNode * &T, vector<char>&ans){
    stack<BiTNode *>stack;
    stack.push(T);

    BiTNode * node = stack.top();
    while(node->lchild != NULL){
        node = node->lchild;
        stack.push(node);
    }

    while(!stack.empty()){

        node = stack.top();
        stack.pop();
        ans.push_back(node->data);
        
        if(node->rchild != NULL){
            node = node->rchild;
            stack.push(node);
        
            while(node->lchild != NULL){
                node = node->lchild;
                stack.push(node);
            }

        }

    }

}


//后序遍历二叉树
void PostOrderRecur(BiTNode * &T){
    if(T){
        PostOrderRecur(T->lchild);
        PostOrderRecur(T->rchild);
        cout << T->data;
    }else{
        cout << "";
    }

}

//后序非递归遍历二叉树

void PostOrderNoRecur(BiTNode * &T,vector<char>&ans){
    stack<BiTNode *> stack1;
    stack<BiTNode *> stack2;
    stack1.push(T);

    while(!stack1.empty()){
        BiTNode * node = stack1.top();
        stack1.pop();
        
        stack2.push(node);

        if(node->lchild != NULL)
            stack1.push(node->lchild);
        if(node->rchild != NULL)
            stack1.push(node->rchild);

    }

    while(!stack2.empty()){
        BiTNode * node = stack2.top();
        stack2.pop();
        ans.push_back(node->data);
    }

}