二叉树的遍历（递归和非递归实现）

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

#define OK 1
#define OVERFLOW -1
#define ERROR 0

typedef int Status; 
typedef struct TreeNode{
    char data;
    TreeNode* left;
    TreeNode* right;
}TreeNode,*PtrNode;

// 先序遍历：递归实现
void PreOrder(PtrNode head){
    //这里判断是否为空了，后面递归的时候就不用判断左右子孩子是否为空了。
    if(!head)
        return ;
    cout<<head->data<<"";
    PreOrder(head->left);
    PreOrder(head->right);
}

// 先序遍历：非递归实现
void ProOrder2(PtrNode head){
    stack<PtrNode> s;
    s.push(head);
    while(!s.empty()){
        //auto可能会根据泛型，自己获得数据类型
        auto tmp=s.top();
        // 出栈
        s.pop();
        cout<<tmp->data<< " ";
        /*
            这里为什么是right的先入栈？
            栈的特性：后入先出，左节点是要先于左节点输出的。
        */
        if(tmp->right)
            s.push(tmp->right);
        if(tmp->left)
            s.push(tmp->left);
    }
}

// 中序遍历：递归实现
void midOrder(PtrNode head){
    if(head==NULL)
        return ;
    midOrder(head->left);
    cout<<head->data<<" ";
    midOrder(head->right);
}

// 中序遍历：非递归实现
void midOrder2(PtrNode head){
    if(head==NULL)
        return ;
    stack<PtrNode> s;
    auto p=head;
    while(!s.empty()||p){
        if(p){
            s.push(p);
            p=p->left;
        }else{
            cout<<s.top()->data<<" ";
            p=s.top()->right;
            s.pop();
        }
    }
}

//后序遍历：递归实现
void PostOrder(PtrNode head){
    if(head==NULL)
        return ;
    
    PostOrder(head->left);
    PostOrder(head->right);
    cout<<head->data<<" ";
}

// 后序遍历：非递归实现
void PostOrder2(PtrNode head){
    if(head==NULL)
        return ;
    /*
        二叉树的后序遍历很难，但是可以先构造，二叉树的后序遍历的反向序列，然后再通过一个栈
        实现后序输出。
    */

    stack<PtrNode> s1;
    stack<PtrNode> s2;
    s1.push(head);
    while(!s1.empty())
    {
        auto t=s1.top();
        s1.pop();
        s2.push(t);
        /*
            这里的代码和先序遍历很像，这里是左子节点先入栈。
            为了构造和后序遍历的完全相反的序列。
        */

        if(t->left!=NULL)
            s1.push(t->left);
        if(t->right!=NULL)
            s1.push(t->right);
    }

    while(!s2.empty()){
        cout<<s2.top()->data<<" ";
        s2.pop();
    }
}

// 层次遍历
void cenciOrder(PtrNode head){

    if(head==NULL)
        return ;

    queue<PtrNode> q;
    q.push(head);
    while(!q.empty()){
        auto tmp=q.front();
        cout<<tmp->data<<" ";
        q.pop();
        if(tmp->left!=NULL){
            q.push(tmp->left);
        }
        if(tmp->right!=NULL){
            q.push(tmp->right);
        }
    }
}