二叉树遍历

　　最近使用了二叉树，除了想起能用递归遍历外，其它的方式却想不通。痛恨自己对事情一知半解，查阅资料，总结

一下，方便理解。

一、各遍历顺序：

　　<1>先序遍历：根->左子树->右子树

　　<2>中序遍历：左子树->根->右子树

　　<3>后序遍历: 左子树->右子树->根

二、代码实现

#include <iostream>
#include <stack>
using namespace std;

struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x): val(x), left(NULL), right(NULL) {}
};
// 先序遍历
void preOrder(TreeNode *root) {
    if (!root) {
        return;
    }

    cout << root->val << ' ';    
    preOrder(root->left);
    preOrder(root->right);
    return;
}

void preOrder2(TreeNode *root) {
    if (!root) {
        return;
    }

    stack<TreeNode *> s;
    s.push(root);
    while(!s.empty()) {
        TreeNode *p = s.top(); s.pop();
        cout << p->val << ' ';

        if (p->right) {
            s.push(p->right);
        }
        if (p->left) {
            s.push(p->left);
        }
    }
    return;
}
//中序遍历
void inOrder(TreeNode *root) {
    if (!root) {
        return;
    }

    inOrder(root->left);
    cout << root->val << ' ';
    inOrder(root->right);
    return;
}

void inOrder2(TreeNode *root) {
    if (!root) {
        return;
    }
    int UNUSED = 0;
    int USED = 1;
    int isUsed;

    TreeNode *p;
    stack<pair<TreeNode *, int> > s;        
    s.push(make_pair(root, UNUSED));
    while (!s.empty()) {
        p = s.top().first;
        isUsed = s.top().second;    
        s.pop();    

        if (!isUsed) {
            if (p->right) {
                s.push(make_pair(p->right, UNUSED));
            }            
            s.push(make_pair(p, USED));
            if (p->left) {
                s.push(make_pair(p->left, UNUSED));
            }
        } else {
            cout << p->val << ' ';
        }
    } 
    return;
}
//后充遍历
void postOrder(TreeNode *root) {
    if (!root) {
        return;
    }

    postOrder(root->left);
    postOrder(root->right);
    cout << root->val << ' ';
    return;
}

void postOrder2(TreeNode *root) {
    if (!root) {
        return;
    }

    int UNUSED = 0;
    int USED = 1;
    int isUsed;

    stack<pair<TreeNode *, int> > s;
    TreeNode *p;

    s.push(make_pair(root, UNUSED));
    while (!s.empty()) {
        p = s.top().first;
        isUsed = s.top().second;
        s.pop();
        if (!isUsed) {
            s.push(make_pair(p, USED));
            if (p->right) {
                s.push(make_pair(p->right, UNUSED));
            }
            if (p->left) {
                s.push(make_pair(p->left, UNUSED));
            }
        } else {
            cout << p->val << ' ';
        }
    }
    return;
}

int main(int argc, char *argv[]) {
    TreeNode *p = new TreeNode(8);
    p->left = new TreeNode(9);
    p->right = new TreeNode(5);
    // 1. preorder traversal
    preOrder(p);

    // 2. preorder traversal 
    preOrder2(p);

    // 3. inorder traversal
    inOrder(p);

    // 4. inorder traversal
    inOrder2(p);

    // 5. postorder traversal
    postOrder(p);

    // 6. postorder traversal
    postOrder2(p);
    return 0;
}