c++通过递归和栈实现二叉树 中序、先序、后序遍历

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

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

//添加节点
void addNode(BinaryTreeNode **rootNode, int value)
{
    BinaryTreeNode *newNode = new BinaryTreeNode();
    newNode->m_pLeft = nullptr;
    newNode->m_pRight = nullptr;
    newNode->m_nValue = value;
    if (*rootNode == nullptr)
    {
        *rootNode = newNode;
        return;
    }
    else
    {
        BinaryTreeNode *pNode = *rootNode;
        BinaryTreeNode *fatherNOde;

        while (pNode != nullptr)
        {
            fatherNOde = pNode;
            if (value < pNode->m_nValue)
            {
                pNode = pNode->m_pLeft;
            }
            else
            {
                pNode = pNode->m_pRight;
            }
        }

        if (value < fatherNOde->m_nValue)
        {
            fatherNOde->m_pLeft = newNode;
        }
        else
        {
            fatherNOde->m_pRight = newNode;
        }
    }
}

//先序遍历 递归实现
void recursionBeforTraverse(BinaryTreeNode *rootNode)
{
    if (rootNode != nullptr)
    {
        cout << rootNode->m_nValue << ",";
        recursionBeforTraverse(rootNode->m_pLeft);
        recursionBeforTraverse(rootNode->m_pRight);
    }
}
//先序遍历 栈实现
void stackBefroTraverse(BinaryTreeNode *rootNode)
{
    if (rootNode != nullptr)
    {
        cout << "stack befor" << endl;
        stack<BinaryTreeNode *> nodes;
        nodes.push(rootNode); //先

        while (!nodes.empty())
        {
            BinaryTreeNode *node = nodes.top();
            nodes.pop();
            cout << node->m_nValue << ",";
            if (node->m_pRight != nullptr)
            {
                nodes.push(node->m_pRight); //添加右节点
            }
            if (node->m_pLeft != nullptr)
            {
                nodes.push(node->m_pLeft); //添加左节点
            }
        }
        cout << endl;
    }
}

//中遍历 递归实现
void recursionMedileTraverse(BinaryTreeNode *rootNode)
{
    if (rootNode != nullptr)
    {
        recursionMedileTraverse(rootNode->m_pLeft); //寻找左节点
        cout << rootNode->m_nValue << ",";
        recursionMedileTraverse(rootNode->m_pRight); //寻找右节点
        return;
    }
}

//中序遍历 栈实现
void stackMedileTraverse(BinaryTreeNode *rootNode)
{
    if (rootNode != nullptr)
    {
        cout << "stack medile" << endl;
        stack<BinaryTreeNode *> nodes;

        while (!nodes.empty() || rootNode != nullptr)
        {
            if (rootNode != nullptr)
            {
                nodes.push(rootNode);
                rootNode = rootNode->m_pLeft; //添加左节点
            }
            else
            {
                rootNode = nodes.top();
                cout << rootNode->m_nValue << ",";
                nodes.pop();
                rootNode = rootNode->m_pRight; //添加右节点，如果它有左节点，还会继续添加
            }
        }
        cout << endl;
    }
}

//后序遍历 递归实现
void recursionEndTraverse(BinaryTreeNode *rootNode)
{
    if (rootNode != nullptr)
    {
        recursionEndTraverse(rootNode->m_pLeft);  //寻找左节点
        recursionEndTraverse(rootNode->m_pRight); //寻找右节点
        cout << rootNode->m_nValue << ",";
        return;
    }
}
//后序遍历 栈实现
void stackEndTraverse(BinaryTreeNode *rootNode)
{
    if (rootNode != nullptr)
    {
        printf("\n stack end \n");
        stack<pair<BinaryTreeNode *, bool>> stack;
        stack.push(make_pair(rootNode, false)); // 添加头结点
        bool visited;                           //是否显示
        while (!stack.empty())
        {
            rootNode = stack.top().first;
            visited = stack.top().second;
            stack.pop(); //出栈
            if (visited)
                cout << rootNode->m_nValue << ",";
            else
            {
                stack.push(make_pair(rootNode, true)); //入栈并设置设置显示
                if (rootNode->m_pRight != nullptr)
                    stack.push(make_pair(rootNode->m_pRight, false)); //设置不显示
                if (rootNode->m_pLeft != nullptr)
                    stack.push(make_pair(rootNode->m_pLeft, false)); //设置不显示
            }
        }
        cout << endl;
    }
}

int main(int argc, char const *argv[])
{
    BinaryTreeNode *root = nullptr;

    int array[] = {10, 6, 14, 4, 8, 12, 16};

    for (int i = 0; i < sizeof(array) / sizeof(int); i++)
    {
        addNode(&root, array[i]);
    }

    printf("befor \n");
    recursionBeforTraverse(root);
    cout << endl;
    stackBefroTraverse(root);

    printf("\n medile \n");
    recursionMedileTraverse(root);
    cout << endl;
    stackMedileTraverse(root);

    printf("end \n");
    recursionEndTraverse(root);
    stackEndTraverse(root);

    return 0;
}