递归、非递归实现二叉树的前中后序遍历

#include <stdlib.h>
#include <iostream>
#include <stack>
using namespace std;

typedef struct pNode *Node;
stack<Node> nodeStack;
//树节点
struct pNode{
	int value;
	Node left;
	Node right;
};

Node initNode(int i ){
	Node t = (Node)malloc(sizeof(*t));
	t->value = i;
	t->left = NULL;
	t->right = NULL;
	return t;
}

void PreOrderTraverse(Node root)
{
    cout << root->value << "\t";
    if(root == NULL)
        return;
    if(root->left != NULL)
        PreOrderTraverse(root->left);
    if(root->right != NULL)
        PreOrderTraverse(root->right);
}

void InOrderTraverse(Node root)
{
    if(root == NULL)
        return;
    if(root->left != NULL)
        InOrderTraverse(root->left);
    cout << root->value << "\t";

    if(root->right != NULL)
        InOrderTraverse(root->right);
}

void PostOrderTraverse(Node root)
{
    if(root == NULL)
        return;
    if(root->left != NULL)
        PostOrderTraverse(root->left);
    if(root->right != NULL)
        PostOrderTraverse(root->right);
    cout << root->value << "\t";
}

void PreOrderWithoutRecursive(Node root)
{
    while((!nodeStack.empty())||(root!=NULL))
    {
        while(root!=NULL)
        {
            cout << root->value << "\t";
            nodeStack.push(root);
            root = root->left;
        }
        if(!nodeStack.empty())
        {
            root = nodeStack.top();
            nodeStack.pop();
            root = root->right;
        }
    }
}

void InOrderWithoutRecursive(Node root)
{
    while((!nodeStack.empty())||(root!=NULL))
    {
        while(root!=NULL)
        {
            nodeStack.push(root);
            root = root->left;
        }
        if(!nodeStack.empty())
        {
            root = nodeStack.top();
            nodeStack.pop();
            cout << root->value << "\t";
            root = root->right;
        }
    }

}

int main(){
	Node root = initNode(88);
	root->left = initNode(44);
	root->right = initNode(99);
	root->left->left = initNode(33);
	root->left->right = initNode(55);
	root->left->left->left = initNode(22);
	root->left->left->left->left = initNode(11);
	root->left->left->left->right = initNode(29);
	root->left->right->left = initNode(48);
	root->left->right->right = initNode(66);
	root->right->left = initNode(89);
	root->right->right = initNode(101);

    PreOrderTraverse(root);
    cout << endl;
    InOrderTraverse(root);
    cout << endl;
    PostOrderTraverse(root);
    cout << endl;
    PreOrderWithoutRecursive(root);
    cout << endl;
    InOrderWithoutRecursive(root);
    cout << endl;
}