C++ 二叉树的三种遍历 递归与非递归

#include <iostream>
#include <stack>

using namespace std;

struct biTreeNode
{
    int val;
    biTreeNode* left;
    biTreeNode* right;
    biTreeNode(int x) : val(x), left(nullptr), right(nullptr)
    {
    };
};

//递归前序遍历
void recurPreOrderTraversal(biTreeNode* curNode)
{
    if(curNode)
    {
        cout << curNode->val << " ";
        recurPreOrderTraversal(curNode->left);
        recurPreOrderTraversal(curNode->right);
    }
}

//非递归前序遍历
void nonRecurPreOrderTraversal(biTreeNode* curNode)
{
    stack<biTreeNode*> nodeStack;
    biTreeNode* nodePtr = curNode;
    while(nodePtr || !nodeStack.empty())
    {
        while(nodePtr)
        {
            cout << nodePtr->val << " ";
            nodeStack.push(nodePtr);
            nodePtr = nodePtr->left;
        }
        if(!nodeStack.empty())
        {
            nodePtr = nodeStack.top();
            nodeStack.pop();
            nodePtr = nodePtr->right;
        }
    }
}
//递归中序遍历
void recurInOrderTraversal(biTreeNode* curNode)
{
    if(curNode)
    {
        recurInOrderTraversal(curNode->left);
        cout << curNode->val << " ";
        recurInOrderTraversal(curNode->right);
    }
}
//非递归中序遍历
void nonRecurInOrderTraversal(biTreeNode* curNode)
{
    stack<biTreeNode*> nodeStack;
    biTreeNode* nodePtr = curNode;

    while(nodePtr || !nodeStack.empty())
    {
        while(nodePtr)
        {
            nodeStack.push(nodePtr);
            nodePtr = nodePtr->left;
        }
        if(!nodeStack.empty())
        {
            cout << nodeStack.top()->val << " ";
            nodePtr = nodeStack.top();
            nodeStack.pop();
            nodePtr = nodePtr->right;
        }
    }
}
//递归后序遍历
void recurPostOrderTraversal(biTreeNode* curNode)
{
    if(curNode)
    {
        recurPostOrderTraversal(curNode->left);
        recurPostOrderTraversal(curNode->right);
        cout << curNode->val << " ";
    }
}
//非递归后序遍历
void nonRecurPostOrderTraversal(biTreeNode* curNode)
{
    //左右子树颠倒的前序遍历，再翻转
    stack<biTreeNode*> nodeStack;
    stack<int> ans;
    biTreeNode* nodePtr = curNode;

    while(nodePtr || !nodeStack.empty())
    {
        while(nodePtr)
        {
            ans.push(nodePtr->val);
            nodeStack.push(nodePtr);
            nodePtr = nodePtr->right;
        }
        
        if(!nodeStack.empty())
        {
            nodePtr = nodeStack.top();
            nodeStack.pop();
            nodePtr = nodePtr->left;
        }
    }

    //输出
    cout << ans.top();
    ans.pop();
    while(!ans.empty())
    {
        cout << " " << ans.top();
        ans.pop();
    }
}
int main()
{
    auto nodePtr1 = new biTreeNode(1);
    auto nodePtr2 = new biTreeNode(2);
    auto nodePtr3 = new biTreeNode(3);

    nodePtr1->left = nodePtr2;
    nodePtr1->right = nodePtr3;
    nodePtr2->left = new biTreeNode(5);
    nodePtr2->right = new biTreeNode(6);
    nodePtr3->right = new biTreeNode(4);

    biTreeNode* head = nodePtr1;

    //递归、非递归 前序遍历
    recurPreOrderTraversal(head);
    cout << endl;
    nonRecurPreOrderTraversal(head);
    cout << endl;

    //递归、非递归 中序遍历
    recurInOrderTraversal(head);
    cout << endl;
    nonRecurInOrderTraversal(head);
    cout << endl;

    //递归、非递归 后序遍历
    recurPostOrderTraversal(head);
    cout << endl;
    nonRecurPostOrderTraversal(head);
    cout << endl;
    return 0;
}