c++ 二叉树前序、中序、后续 递归和非递归版本

#include<iostream>
#include<stack>

using namespace std;

struct node{
    int value;
    node* left;
    node* right;
    node(int value):
        value(value), left(NULL),right(NULL) {}
};

void preOrderRecur(node* head){
    if(head == NULL){
        return;
    }
    cout << head-> value << ",";
    preOrderRecur(head->left);
    preOrderRecur(head->right);
}
void inOrderRecur(node* head){
    if(head == NULL){
        return;
    }
    inOrderRecur(head->left);
    cout << head-> value << ",";
    inOrderRecur(head->right);
}
void postOrderRecur(node* head){
    if(head == NULL){
        return;
    }
    postOrderRecur(head->left);
    postOrderRecur(head->right);
    cout << head-> value << ",";
}

void preOrderUnrecur(node* head){
    if (head == NULL){
        return;
    }
    stack<node*>newstack;
    newstack.push(head);
    while (!newstack.empty()){
        node* head = newstack.top();
        cout << head->value << ",";
        newstack.pop();
        if (head->right != NULL){
            newstack.push(head->right);
        }
        if (head->left != NULL){
            newstack.push(head->left);
        }
    }
}

void inOrderUnrecur(node* head){
    if (head == NULL){
        return;
    }
    stack<node*>newstack;
    while (!newstack.empty() || head != NULL){
        if (head != NULL){
            newstack.push(head);
            head = head->left;
        }
        else{
            head = newstack.top();
            cout << head->value << ",";
            newstack.pop();
            head = head->right;
        }
    }
}

void postOrderunrecur(node* head){
    if (head == NULL){
        return;
    }
    stack<node*> stack1, stack2;
    stack1.push(head);
    while (!stack1.empty()){
        node* head = stack1.top();
        stack2.push(head);
        stack1.pop();
        if (head-> left != NULL){
            stack1.push(head->left);
        }
        if (head->right != NULL){
            stack1.push(head->right);
        }
    }
    while (!stack2.empty()){
        cout << stack2.top()->value << ",";
        stack2.pop();
    }
}

int main(){
    node* head = new node(1);
    head->left = new node(3);
    head->right = new node(8);
    head->left->left = new node(6);
    head->left->right = new node(4);
    head->right->left = new node(7);
    head->right->right = new node(10);
    head->right->left->left = new node(5);
    head->right->right->left = new node(2);
    head->right->right->right = new node(18);
    cout << "==============recursive preOrder=============="<< endl;
    preOrderRecur(head);
    cout << endl;
    cout << "==============unrecursive preOrder=============="<< endl;
    preOrderUnrecur(head);
    cout << endl;
    cout << "==============recursive inOrder=============="<< endl;
    inOrderRecur(head);
    cout << endl;
    cout << "==============unrecursive inOrder=============="<< endl;
    inOrderUnrecur(head);
    cout << endl;
    cout << "==============recursive postOrder=============="<< endl;
    postOrderRecur(head);
    cout << endl;
    cout << "==============unrecursive postOrder=============="<< endl;
    postOrderunrecur(head);
    cout << endl;
}