分别用递归和非递归的方式实现二叉树的先序、中序和后序遍历

#include "Tree.h"
using namespace std;
//先序递归实现
void preOrder(Node* head)
{
    if(head == nullptr)
        return;
    cout << head->value << endl;
    preOrder(head->left);
    preOrder(head->right);
    return;
}

//中序递归实现
void inOrder(Node* head)
{
    if(head == nullptr)
        return;

    inOrder(head->left);
    cout << head->value << endl;
    inOrder(head->right);
    return;
}
//后序递归实现
void posOrder(Node* head)
{
    if(head == nullptr)
        return;
    posOrder(head->left);
    posOrder(head->right);
    cout << head->value << endl;
    return;
}
//先序非递归实现
void preOrderUn(Node* head)
{
    if(head != nullptr)
    {
        stack<Node*> nStack;
        nStack.push(head);
        while(!nStack.empty())
        {
            head = nStack.top();
            nStack.pop();
            cout << head->value << endl;
            if(head->right)
                nStack.push(head->right);
            if(head->left)
                nStack.push(head->left);
        }
    }
    return;
}
//中序非递归实现
void inOrderUn(Node* head)
{
    if(head)
    {
        stack<Node*> nStack;
        while(!nStack.empty() || head )
        {
            if(head)
            {
                nStack.push(head);
                head = head->left;
            }
            else
            {
                head = nStack.top();
                cout << head->value << endl;
                nStack.pop();
                head = head->right;
            }
        }
    }
    return;
}
//后序非递归实现
void posOrderUn(Node* head)
{
    if(head)
    {
        stack<Node*> nStack1;
        stack<Node*> nStack2;
        nStack1.push(head);
        while(!nStack1.empty())
        {
            Node* pNode = nStack1.top();
            nStack1.pop();
            nStack2.push(pNode);
            if(pNode->left)
                nStack1.push(pNode->left);
            if(pNode->right)
                nStack1.push(pNode->right);
        }

        while(!nStack2.empty())
        {
            cout << nStack2.top()->value << endl;
            nStack2.pop();
        }
    }
}
//后序非递归实现2
void posOrderUn2(Node* head)
{
    if(head)
    {
        stack<Node*> nstack;
        nstack.push(head);
        Node* c = nullptr;
        while(!nstack.empty())
        {
            c = nstack.top();
            if(c->left != nullptr && head != c->left && head != c->right)
            {
                nstack.push(c->left);
            }
            else if(c->right != nullptr && head != c->right)
            {
                nstack.push(c->right);
            }
            else
            {
                cout << nstack.top()->value << endl;
                nstack.pop();
                head = c;
            }
        }
    }
}

int main()
{
    Node* pNode0 = new Node(0);
    Node* pNode1 = new Node(1);
    Node* pNode2 = new Node(2);
    Node* pNode3 = new Node(3);
    Node* pNode4 = new Node(4);
    Node* pNode5 = new Node(5);
    Node* pNode6 = new Node(6);

    connectTree(pNode0, pNode1, pNode2);
    connectTree(pNode1, pNode3, pNode4);
    connectTree(pNode2, pNode5, pNode6);

    preOrder(pNode0);
    cout << "==================" << endl;
    preOrderUn(pNode0);
    cout << "==================" << endl;
    inOrder(pNode0);
    cout << "==================" << endl;
    inOrderUn(pNode0);
    cout << "==================" << endl;
    posOrder(pNode0);
    cout << "==================" << endl;
    posOrderUn(pNode0);
    cout << "==================" << endl;
    posOrderUn2(pNode0);

}