二叉树的遍历

二叉树的数据结构

struct BinaryTreeNode
{
    int m_nValue;
    BinaryTreeNode*   m_pLeft;
    BinaryTreeNode*   m_pRight;
};

前序遍历的非递归实现

void PreOrder(BinaryTreeNode* root)
{
    if (root == NULL)
        return;
    BinaryTreeNode* p = root;
    stack<BinaryTreeNode*> s;
    while (!s.empty() || p)
    {
        while (p)
        {
            cout << p->m_nValue << " ";
            s.push(p);
            p = p->m_pLeft;
        }
        if (!s.empty())
        {
            p = s.top();
            s.pop();
            p = p->m_pRight;
        }
    }
    cout << endl;
}   

中序遍历的非递归实现

void InOrder(BinaryTreeNode* root)
{
    if (root == NULL)
        return;
    BinaryTreeNode* p = root;
    stack<BinaryTreeNode*> s;
    while (!s.empty() || p)
    {
        while (p)
        {
            s.push(p);
            p = p->m_pLeft;
        }
        if (!s.empty())
        {
            p = s.top();
            s.pop();
            cout << p->m_nValue << " ";
            p = p->m_pRight;
        }
    }
}

后序遍历的非递归实现

后序遍历递归定义：先左子树，后右子树，再根节点。后序遍历的难点在于：需要判断上次访问的节点是位于左子树，还是右子树。若是位于左子树，则需跳过根节点，先进入右子树，再回头访问根节点；若是位于右子树，则直接访问根节点。

void PostOrder(BinaryTreeNode* root)
{
    if (root == nullptr)
        return;
    stack<BinaryTreeNode*> s;
    BinaryTreeNode *pCur, *pLastVisit;
    pCur = root;
    pLastVisit = nullptr;
    while (pCur)
    {
        s.push(pCur);
        pCur = pCur->m_pLeft;
    }
    while (!s.empty())
    {
        pCur = s.top();
        s.pop();
        if (pCur->m_pLeft == nullptr || pCur->m_pRight == pLastVisit)
        {
            cout << pCur->m_nValue << " ";
            pLastVisit = pCur;
        }
        else
        {
            s.push(pCur);
            pCur = pCur->m_pRight;
            while (pCur)
            {
                s.push(pCur);
                pCur = pCur->m_pLeft;
            }
        }
    }
    cout << endl;
}

前序遍历的递归实现

void PreOrder(BinaryTreeNode* pRoot)  
{  
    if (pRoot!=NULL)  
    {  
        visit(*pRoot);//visit只是代表处理，关键的是结构  
        PreOrder(pRoot->m_pLeft);  
        PreOrder(pRoot->m_pRight);  
    }     
}  

中序遍历的递归实现

void InOrder(BinaryTreeNode* pRoot)  
{  
    if (pRoot!=NULL)  
    {  
        InOrder(pRoot->m_pLeft);  
        visit(*pRoot); //visit只是代表处理，关键的是结构  
        InOrder(pRoot->m_pRight);  
    }     
}  

后序遍历的递归实现

void PostOrder(BinaryTreeNode* pRoot)  
{  
    if (pRoot!=NULL)  
    {  
        PostOrder(pRoot->m_pLeft);  
        PostOrder(pRoot->m_pRight);  
        visit(*pRoot);//visit只是代表处理，关键的是结构  
    }     
}