遍历二叉树

//µÝ¹éºÍ·ÇµÝ¹é±éÀúTree
//         1
//       /   \
//      2     3
//     / \   / \
//    4   5 6   7
//Pre-Order: 1 2 4 5 3 6 7
//In-Order:  4 2 5 1 6 3 7
//Post-Order:4 5 2 6 7 3 1

#include <iostream>
#include <cstdio>
#include <stack>

using namespace std;

typedef struct node
{
    int val;
    struct node *lc;
    struct node *rc;
    node(int v1, struct node* _lc, struct node* _rc):val(v1),lc(_lc),rc(_rc){};
}Node;

Node* createTree()
{
    Node *n4 = new Node(4,NULL,NULL);
    Node *n5 = new Node(5,NULL,NULL);
    Node *n6 = new Node(6,NULL,NULL);
    Node *n7 = new Node(7,NULL,NULL);
    Node *n2 = new Node(2,n4,n5);
    Node *n3 = new Node(3,n6,n7);
    Node *n1 = new Node(1,n2,n3);
    return n1;
}

int treeHeight;
void treeHigh(Node *p, int depth)
{
    if(!p)
    {
        if(depth>treeHeight)
        {
            treeHeight=depth;
        }
        return;
    }
    treeHigh(p->lc,depth+1);
    treeHigh(p->rc,depth+1);
}

int treeHigh1(Node *p)
{
    int hl,hr;
    if(!p)
    {
        return 0;
    }
    hl=treeHigh1(p->lc);
    hr=treeHigh1(p->rc);
    return  (hl>hr?hl:hr)+1;
}

void preOrder(const Node * p)
{
    if(!p)
    {
        return;
    }
    printf("%d\n",p->val);
    preOrder(p->lc);
    preOrder(p->rc);
}

void preOrder1(Node *p)
{
    stack<Node*> ns;

    while(!ns.empty() || p)
    {
        while(p)
        {
            printf("%d\n",p->val);
            ns.push(p);
            p=p->lc;
        }
        if(!ns.empty())
        {
            p=ns.top();
            ns.pop();
            p=p->rc;
        }
    }
}

void inOrder(const Node *p)
{
    if(!p)
    {
        return;
    }
    inOrder(p->lc);
    printf("%d\n",p->val);
    inOrder(p->rc);
}

void inOrder1(Node *p)
{
    stack<Node*> ns;

    while(!ns.empty()||p)
    {
        while(p)
        {
            ns.push(p);
            p=p->lc;
        }
        if(!ns.empty())
        {
            p=ns.top();
            printf("%d\n",p->val);
            ns.pop();
            p=p->rc;
        }
    }
}

void postOrder(const Node *p)
{
    if(!p)
    {
        return;
    }
    postOrder(p->lc);
    postOrder(p->rc);
    printf("%d\n",p->val);
}

void postOrder1(Node *p)
{
    stack<Node *> ns;
    bool tag[8] = {false};

    while(!ns.empty() || p)
    {
        while(p)
        {
            ns.push(p);
            p=p->lc;
        }
        while(!ns.empty()&&tag[ns.top()->val]==true)
        {
            p=ns.top();
            printf("%d\n",p->val);
            ns.pop();
        }
        if(!ns.empty())
        {
            p=ns.top();
            tag[p->val]=true;
            p=p->rc;
        }
        else
        {
            p=NULL;
        }
    }
}

int main()
{
    Node *root;

    root=createTree();

    printf("preOrder Travel:\n");
    preOrder(root);
    printf("\n\n");

    printf("InOrder Travel:\n");
    inOrder(root);
    printf("\n\n");

    printf("PostOrder Travel:\n");
    postOrder(root);
    printf("\n\n");

    //with stack, non-recursive travel
    printf("preOrder1 Travel:\n");
    preOrder1(root);
    printf("\n\n");

    printf("InOrder1 Travel:\n");
    inOrder1(root);
    printf("\n\n");

    printf("PostOrder1 Travel:\n");
    postOrder1(root);
    printf("\n\n");

    treeHeight=0;
    treeHigh(root,0);
    printf("treeHeight:%d\n",treeHeight);
    printf("treeHeight1:%d\n",treeHigh1(root));

    return 0;
}