树的一些操作——遍历，前序和中序建立后续

#include <iostream>
#include <cstring>
#include <stack>
#include <queue>
#include <cmath>
#include <exception>
#include <stdexcept>

using namespace std;

typedef struct Node {
    int key;
    struct Node *left;
    struct Node *right;
}Node;


void PreOrder(Node* head) {
    if(head) {
        cout<<head->key<<"	";
        PreOrder(head->left);
        PreOrder(head->right);
    }
}

void InOrder(Node* head) {
    if(head) {
        InOrder(head->left);
        cout<<head->key<<"	";
        InOrder(head->right);
    }
}

void PostOrder(Node* head) {
    if(head) {
        PostOrder(head->left);
        PostOrder(head->right);
        cout<<head->key<<"	";
    }
}

void IterInOrder(Node* head) {
    stack<Node*> ss;
    Node* headCp = head;
    for(;;) {
        for(;headCp;headCp=headCp->left) {
            ss.push(headCp);
        }
        if(ss.size()!=0) { // key point, if stack is of no item inside, top() will cause trouble.
            headCp = ss.top();
            ss.pop();
        }
        if(!headCp) {
            break;
        }
        cout<<headCp->key<<"	";
        headCp = headCp->right;
    }
}

void LevelOrder(Node* head) {
    queue<Node*> que;
    if(!head) {
        return;
    }
    que.push(head);
    for(;;) {
        if(que.size()==0) {
            break;
        }
        head = que.front();
        que.pop();
        if(head) {
            cout<<head->key<<"	";
            if(head->left) {
                que.push(head->left);
            }
            if(head->right) {
                que.push(head->right);
            }
        }
    }
}

Node* BuildTree(int* startPreorder, int* endPreorder, int* startInorder, int* endInorder);

Node* ConstructNewTree(int* PreOrderArr, int* InOrderArr, int length) {
        if(PreOrderArr == NULL || InOrderArr == NULL || length == 0) {
            return NULL;
        } else {
            int* startPreorder = PreOrderArr;
            int* endPreorder = PreOrderArr+length-1;
            int* startInorder = InOrderArr;
            int* endInorder = InOrderArr+length-1;
            return BuildTree(startPreorder,endPreorder,startInorder,endInorder);
        }
}

Node* BuildTree(int* startPreorder, int* endPreorder, int* startInorder, int* endInorder) {
    int rootValue = -1;
    if(startPreorder == NULL || endPreorder==NULL || startInorder==NULL || endInorder==NULL) {
        return NULL;
    } else {
        rootValue = *startPreorder;
    }
    Node* root = new Node();
    root->key = rootValue;
    root->left = NULL;
    root->right = NULL;

    if(startPreorder==endPreorder) {
        if(startInorder==endInorder && *startPreorder == *startInorder) {
            return root;
        } else {
            throw exception();
        }
    }

    int* rootInorder = startInorder;
    while(rootInorder<=endInorder && *rootInorder!=rootValue) {
        rootInorder++;
    }
    if(*rootInorder!=rootValue) {
        throw exception();
    }
    int leftLen = rootInorder-startInorder;
    int righLen = endInorder-rootInorder;
    int* leftPreorderEnd = startPreorder+leftLen;
    if(leftLen>0) {
        root->left = BuildTree(startPreorder+1,leftPreorderEnd,startInorder,rootInorder-1);
    }
    if(righLen>0) {
        root->right = BuildTree(leftPreorderEnd+1,endPreorder,rootInorder+1,endInorder);
    }
    return root;
}


int main(int argc, char* argv[]) {
    Node node1,node2,node3,node4,node5,node6,node7,node8;

    node1.key = 1;
    node1.left = &node2;
    node1.right = &node3;

    node2.key = 2;
    node2.left = &node4;
    node2.right = NULL;

    node3.key = 3;
    node3.left = &node5;
    node3.right = &node6;

    node4.key = 4;
    node4.left = NULL;
    node4.right = &node7;

    node5.key = 5;
    node5.left = NULL;
    node5.right = NULL;

    node6.key = 6;
    node6.left = &node8;
    node6.right = NULL;

    node7.key = 7;
    node7.left = NULL;
    node7.right = NULL;

    node8.key = 8;
    node8.left = NULL;
    node8.right = NULL;

    cout<<"preorder:"<<endl;
    PreOrder(&node1);
    cout<<endl;

    cout<<"inorder:"<<endl;
    InOrder(&node1);
    cout<<endl;


/*
    cout<<"PreOrder:
";
    PreOrder(&node1);
    cout<<endl;

    cout<<"recursive InOrder:
";
    InOrder(&node1);
    cout<<endl;

    cout<<"loop InOrder:
";
    IterInOrder(&node1);
    cout<<endl;

    cout<<"PostOrder:
";
    PostOrder(&node1);
    cout<<endl;

    cout<<"Level Order:
";
    LevelOrder(&node1);
    cout<<endl;
*/

    cout<<"start building the tree ..."<<endl;
    int PreorderArr[] = {1,2,4,7,3,5,6,8};
    int InorderArr[] = {4,7,2,1,5,3,8,6};
    Node* root = ConstructNewTree(PreorderArr,InorderArr,sizeof(PreorderArr)/sizeof(int));
    cout<<"build done."<<endl;

    cout<<"preorder:"<<endl;
    PreOrder(root);
    cout<<endl;
    cout<<"inorder:"<<endl;
    InOrder(root);
    cout<<endl;
    cout<<"postorder:"<<endl;
    PostOrder(root);
    cout<<endl;

    return 0;
}