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

一.前序遍历

前序遍历按照“根结点-左孩子-右孩子”的顺序进行访问。

1.递归实现

void pre_order(BTree *root)    
{    
    if(root != NULL)//必不可少的条件,递归的出口    
    {    
        printf("%2c",root->key);    //访问根结点
        pre_order(root->lchild);     //前序遍历左子树 
        pre_order(root->rchild);    //前序遍历右子树   
    }    
}    

2.非递归实现

根据前序遍历访问的顺序，优先访问根结点，然后再分别访问左孩子和右孩子。即对于任一结点，其可看做是根结点，因此可以直接访问，访问完之后，若其左孩子不为空，按相同规则访问它的左子树；当访问其左子树时，再访问它的右子树。因此其处理过程如下：
对于任一结点P：

1)访问结点P，并将结点P入栈;

2)判断结点P的左孩子是否为空，若为空，则取栈顶结点并进行出栈操作，并将栈顶结点的右孩子置为当前的结点P，循环至1);若不为空，则将P的左孩子置为当前的结点P;
3)直到P为NULL并且栈为空，则遍历结束。

void _PrevOrderNotRecursion(Node<T>* root)
    {
        stack<Node<T>*> s;
        Node<T>* p = root;
        while (p || !s.empty())
        {
            while (p)
            {
                cout<<p->_data<<" ";
                s.push(p);
                p = p->_pLeft;
            }
            if (!s.empty())
            {
                p = s.top();
                s.pop();
                p = p->_pRight;
            }
        }
    }

二.中序遍历

中序遍历按照“左孩子-根结点-右孩子”的顺序进行访问。

1.递归实现

void in_order(BTree* root)    
{    
    //必不可少的条件,递归的出口   
     if(root != NULL)   
    {    
        in_order(root->lchild);    
        printf("%2c",root->data);    
        in_order(root->rchild);      
    }    
}     

2.非递归实现

根据中序遍历的顺序，对于任一结点，优先访问其左孩子，而左孩子结点又可以看做一根结点，然后继续访问其左孩子结点，直到遇到左孩子结点为空的结点才进行访问，然后按相同的规则访问其右子树。因此其处理过程如下：

对于任一结点P，

1)若其左孩子不为空，则将P入栈并将P的左孩子置为当前的P，然后对当前结点P再进行相同的处理；

2)若其左孩子为空，则取栈顶元素并进行出栈操作，访问该栈顶结点，然后将当前的P置为栈顶结点的右孩子；

3)直到P为NULL并且栈为空则遍历结束

//非递归中序遍历

void in_order(BTree *root)       
{  
    stack<BTree*> s;  
    BTree *p = root;  
    while (p != NULL || !s.empty()) {  
    while(p != NULL) {              
        s.push(p);  
        p = p->lchild;  
    }  
    if (!s.empty()) {  
        p = s.top();              
        cout<<p->data<<" ";  
        s.pop();  
        p = p->rchild;  
    }  
    }  
} 

三.后序遍历

后序遍历按照“左孩子-右孩子-根结点”的顺序进行访问。

1.递归实现

void post_order(BTree* root)    
{    
    //必不可少的条件,递归的出口   
    if(root != NULL)   
    {    
        post_order(root->lchild);    
        post_order(root->rchild);    
        printf("%2c",root->data);    
    }    
}      

2.非递归实现

后序遍历的非递归实现是三种遍历方式中最难的一种。因为在后序遍历中，要保证左孩子和右孩子都已被访问并且左孩子在右孩子前访问才能访问根结点，这就为流程的控制带来了难题。下面介绍两种思路。

第一种思路：对于任一结点P，将其入栈，然后沿其左子树一直往下搜索，直到搜索到没有左孩子的结点，此时该结点出现在栈顶，但是此时不能将其出栈并访问， 因此其右孩子还未被访问。所以接下来按照相同的规则对其右子树进行相同的处理，当访问完其右孩子时，该结点又出现在栈顶，此时可以将其出栈并访问。这样就 保证了正确的访问顺序。可以看出，在这个过程中，每个结点都两次出现在栈顶，只有在第二次出现在栈顶时，才能访问它。因此需要多设置一个变量标识该结点是 否是第一次出现在栈顶。

方 法：要保证根结点在左孩子和右孩子访问之后才能访问，因此对于任一结点P，先将其入栈。如果P不存在左孩子和右孩子，则可以直接访问它；或者P存在左孩子 或者右孩子，但是其左孩子和右孩子都已被访问过了，则同样可以直接访问该结点。若非上述两种情况，则将P的右孩子和左孩子依次入栈，这样就保证了每次取栈 顶元素的时候，左孩子在右孩子前面被访问，左孩子和右孩子都在根结点前面被访问。

//非递归后序遍历  
void post_order(BTree* root)       
{  
    stack<BTree*> s;  
    //当前结点  
    BTree *cur = NULL;     
    //前一次访问的结点   
    BTree *pre = NULL;        
    s.push(root);  
    while(!s.empty()) {  
        cur = s.top();  
        if( (cur->lchild == NULL && cur->rchild == NULL) ||  
            (pre != NULL && (pre == cur->lchild || pre == cur->rchild)))  
        {  
            //如果当前结点没有孩子结点或者孩子节点都已被访问过   
            cout<<cur->data<<" ";                  
            s.pop();  
            pre = cur;   
        } else {  
            if(cur->rchild != NULL)   
                s.push(cur->rchild);  
            if(cur->lchild!=NULL)     
                s.push(cur->lchild);  
        }  
    }      
}  

下面是实现的完整代码

TracerseTree.h

#define _CRT_SECURE_NO_WARNINGS 1

#pragma once
#include<iostream>
#include<stack>

using namespace std;

template <typename T>
struct Node  
{
    T _data;
    Node<T>* _pLeft;
    Node<T>* _pRight;
    Node(const T& data)
        :_data(data)
        ,_pLeft(NULL)
        ,_pRight(NULL)
    {}
};

template<typename T>
class BinaryTree
{
public:
    BinaryTree()
        :_root(NULL)
    {}

    BinaryTree(char* str)
    {
        _CreateTree(_root, str);
    }

    BinaryTree(BinaryTree<T>& t);
    BinaryTree& operator=(BinaryTree<T>& t);
    ~BinaryTree()
    {
        //_DestoryTree(_root);
    }

    void _CreateTree(Node<T>*& _root, char*& str)
    {
        if (*str!='#' && *str!='\0')
        {
            _root = new Node<T>(*str);
            _CreateTree(_root->_pLeft,++str);
            _CreateTree(_root->_pRight,++str);
        }
    }

    void PrevOrder1()
    {
        _PrevOrderRecursion(_root);
        cout<<endl;
    }

    void PrevOrder2()
    {
        _PrevOrderNotRecursion(_root);
        cout<<endl;
    }

    void InOrder1()
    {
        _InOrderRecursion(_root);
        cout<<endl;
    }

    void InOrder2()
    {
        _InOrderRecursion(_root);
        cout<<endl;
    }

    void PostOrder1()
    {
        _PostOrderRecursion(_root);
        cout<<endl;
    }
    void PostOrder2()
    {
        _PostOrderRecursion(_root);
        cout<<endl;
    }
protected:
    void _PrevOrderRecursion(Node<T>* root)
    {
        if (root)
        {
            cout<<root->_data<<" ";
            _PrevOrderRecursion(root->_pLeft);
            _PrevOrderRecursion(root->_pRight);
        }
    }

    void _PrevOrderNotRecursion(Node<T>* root)
    {
        stack<Node<T>*> s;
        Node<T>* p = root;
        while (p || !s.empty())
        {
            while (p)
            {
                cout<<p->_data<<" ";
                s.push(p);
                p = p->_pLeft;
            }
            if (!s.empty())
            {
                p = s.top();
                s.pop();
                p = p->_pRight;
            }
        }
    }

    void _InOrderRecursion(Node<T>* root)
    {
        if (root)
        {
            _InOrderRecursion(root->_pLeft);
            cout<<root->_data<<" ";
            _InOrderRecursion(root->_pRight);
        }
    }

    void _InOrderNotRecursion(Node<T>* root)
    {
        stack<Node<T>*> s;
        Node<T> p = root;
        if (p || !s.empty())
        {
            while (p)
            {
                s.push(p);
                p = p->_pLeft;
            }
            if (!s.empty())
            {
                p = s.top();
                cout<<p->_data<<" ";
                s.pop();
                p = p->_pRight;
            }
        }
    }

    void _PostOrderRecursion(Node<T>* root)
    {
        if (root)
        {
            _PostOrderRecursion(root->_pLeft);
            _PostOrderRecursion(root->_pRight);
            cout<<root->_data<<" ";
        }
    }

    void _PostOrderNotRecursion(Node<T>* root)
    {
        stack<Node<T>*> s;
        Node<T>* cur = NULL;
        Node<T>* pre = NULL;
        s.push(root);
        while (!s.empty())
        {
            cur = s.top();
            if ((cur->_pLeft==NULL && cur->_pRight==NULL) || pre=cur->_pLeft || pre=cur->_pRight )
            {
                cout<<cur->_data<<" ";
                s.pop();
                pre = cur;
            }
            else
            {
                if (cur->_pRight != NULL)
                    s.push(cur->_pRight);
                if (cur->_pLeft != NULL)
                    s.push(cur->_pLeft);
            }
        }
    }
private:
    Node<T>* _root;
};

测试代码

#include"TracerseTree.h"

void Test()
{
    char *str = "123##4##56";
    BinaryTree<char> bt1(str);
    bt1.PrevOrder1();
    bt1.PrevOrder2();
    bt1.InOrder1();
    bt1.InOrder2();
    bt1.PostOrder1();
    bt1.PostOrder2();
}

int main()
{
    Test();
    return 0;
}