二叉树前中后序递归和非递归的实现

以防生疏，所以今天又写了一下二叉树的前中后序递归和非递归的实现：

二叉树的节点数据结构：

struct BinaryTreeNode
{
    int nData;

    BinaryTreeNode *lChild;
    BinaryTreeNode *rChild;
};

最后用来测试的树：

                  1

               /     \

            2          4

                \      /    \

                  3 5       6

                                 \

                                   7

前序递归代码：

void RecursionBinaryTreePreOrder(BinaryTreeNode *root)
{
    if (NULL == root)
    {
        return;
    }

    // 打印根节点
    cout << root->nData << " ";

    // 打印左孩子
    RecursionBinaryTreePreOrder (root->lChild);

    // 打印右孩子
    RecursionBinaryTreePreOrder (root->rChild);
}

二叉树前序非递归遍历写了两种方式：

// 两种二叉树前序的非递归遍历方式
// 第一种
void BinaryTreePreOrder(BinaryTreeNode *root)
{
    assert (root != NULL);

    BinaryTreeNode *Stack[MAX];
    int nTop = -1;

    // 根节点入栈
    Stack[++nTop] = root;
    
    while (nTop >= 0)
    {
        // 弹出并访问根节点
        BinaryTreeNode *pTemp = Stack[nTop--];

        cout << pTemp->nData << " ";

        // 因为根节点的左孩子要优于右孩子先访问，
        // 根据栈FILO（先进后出）的特点，因此根节点的右孩子要先入栈
        if (pTemp->rChild != NULL)
        {
            Stack[++nTop] = pTemp->rChild;
        }

        if (pTemp->lChild != NULL)
        {
            Stack[++nTop] = pTemp->lChild;
        }
    }
}

// 另一种非递归方式，这种方式是用栈来严格模拟递归的遍历方式
void AnotherBinaryTreePreOrder(BinaryTreeNode *root)
{
    assert (root != NULL);

    BinaryTreeNode *Stack[MAX];
    int nTop = -1;
    BinaryTreeNode *pTemp = root;

    while (pTemp != NULL)
    {
        cout << pTemp->nData << " ";

        Stack[++nTop] = pTemp;
        pTemp = pTemp->lChild;
    }

    while (nTop >= 0)
    {
        pTemp = Stack[nTop--]->rChild;

        while (pTemp != NULL)
        {
            cout << pTemp->nData << " ";

            Stack[++nTop] = pTemp;
            pTemp = pTemp->lChild;
        }
    }
}

中序递归遍历：

// 二叉树中序的递归遍历方式
void RecursionBinaryTreeInOrder(BinaryTreeNode *root)
{
    if (NULL == root)
    {
        return;
    }

    // 先打印左孩子
    RecursionBinaryTreeInOrder (root->lChild);

    // 再打印根节点
    cout << root->nData << " ";

    // 最后打印右孩子
    RecursionBinaryTreeInOrder (root->rChild);
}

中序非递归遍历：

// 二叉树中序的非递归遍历方式，用栈严格模拟递归的调用
void BinaryTreeInOrder(BinaryTreeNode *root)
{
    assert (root != NULL);

    BinaryTreeNode *Stack[MAX];
    int nTop = -1;

    // 根节点首先入栈
    Stack[++nTop] = root;

    // 先要打印左孩子
    BinaryTreeNode *Current = root->lChild;

    while ((Current != NULL) || (nTop >= 0))
    {
        while (Current != NULL)
        {
            Stack[++nTop] = Current;
            Current = Current->lChild;
        }

        // 打印根节点
        Current = Stack[nTop--];
        cout << Current->nData << " ";

        // 打印右孩子
        Current = Current->rChild;
    }
}

后序递归遍历：

// 二叉树后序的递归遍历方式
void RecursionBinaryTreePostOrder(BinaryTreeNode *root)
{
    if (NULL == root)
    {
        return;
    }

    // 打印左孩子
    RecursionBinaryTreePostOrder (root->lChild);

    // 打印右孩子
    RecursionBinaryTreePostOrder (root->rChild);

    // 打印根节点
    cout << root->nData << " ";
}

后序非递归遍历也写了两种方式：

// 二叉树后序的一种非递归遍历方式
void BinaryTreePostOrder(BinaryTreeNode *root)
{
    assert (root != NULL);

    BinaryTreeNode *Stack[MAX];
    int nTop = -1;

    BinaryTreeNode *Current = root;
    BinaryTreeNode *Previewed = NULL;

    while ((Current != NULL) || (nTop >= 0))
    {
        // 打印左孩子
        while (Current != NULL)
        {
            Stack[++nTop] = Current;
            Current = Current->lChild;
        }

        // 左孩子打印完，当其没有右孩子或右孩子已经被访问过，就打印根节点
        // ，否则打印右孩子
        Current = Stack[nTop];

        if ((NULL == Current->rChild) || (Previewed == Current->rChild))
        {
            cout << Current->nData << " ";
            Previewed = Current;
            Current = NULL;
            --nTop;
        }
        else
        {
            Current = Current->rChild;
        }
    }
}

// 二叉树后序的另一种非递归遍历方式
void AnotherBinaryTreePostOrder(BinaryTreeNode *root)
{
    assert (root != NULL);

    BinaryTreeNode *Stack1[MAX];
    int nTop1 = -1;

    BinaryTreeNode *Stack2[MAX];
    int nTop2 = -1;

    Stack1[++nTop1] = root;

    while (nTop1 >= 0)
    {
        BinaryTreeNode *pTemp = Stack1[nTop1--];
        Stack2[++nTop2] = pTemp;

        if (pTemp->lChild != NULL)
        {
            Stack1[++nTop1] = pTemp->lChild;
        }

        if (pTemp->rChild != NULL)
        {
            Stack1[++nTop1] = pTemp->rChild;
        }
    }

    while (nTop2 >= 0)
    {
        cout << Stack2[nTop2--]->nData << " ";
    }
}

测试结果：