树的几种非递归遍历

• 先序

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> res;
        if(!root)
            return res;
        stack<TreeNode * > s;
        s.push(root);
        TreeNode * node;
        while(!s.empty()){
            node = s.top();
            s.pop();
            res.push_back(node->val);
            if(node->right) //注意这里push的时候是先右后左push
                s.push(node->right);
            if(node->left)
                s.push(node->left);
        }
        return res;
    }
};

• 中序：

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> res;
        stack<TreeNode *> s;
        map<TreeNode *, bool> m;
        if(!root)
            return res;
        TreeNode * node;
        m[root] = true;
        s.push(root);
        while(!s.empty()){
            node = s.top(); //注意，后面也保证了node和s的top的值相同
            while(node->left && m[node->left] == false){
                m[node->left] = true; // tranversed
                s.push(node->left);
                node = node->left;
            }
            res.push_back(node->val);
            s.pop();
            if(node->right && m[node->right] == false){
                m[node->right] = true;
                s.push(node->right);
                node = node->right;
            }
        }
        return res;

    }
};

• 后序

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        stack<TreeNode *> s;
        vector<int> res;
        if(!root)
            return res;
        TreeNode * node = root;
        s.push(root);
        map<TreeNode *, bool> m;
        m[root] = true;
        while(!s.empty()){
            node = s.top();
            while(node->left && !m[node->left]){
                s.push(node->left);
                m[node->left] = true;
                node = node->left; //保证node的值和s的top的值同步了
            }
            if(!node->right || m[node->right]){//保证在访问根节点之前其左右节点都已经访问过了
                res.push_back(node->val);
                s.pop();
            }
            if(node->right && !m[node->right]){
                s.push(node->right);
                m[node->right] = true;
                node = node->right;
            }
        }
        return res;
    }
};

• 注意一点，前序以及中序遍历实际上什么的都不需要，只需要一个栈就可以了，代码如下：

//preOrder
ArrayList<Integer> preOrder(TreeNode root) {
    Stack<TreeNode> stack = new Stack<TreeNode>();
    ArrayList<Integer> arrayList = new ArrayList<Integer>();
    TreeNode p = root;
    while (!stack.empty() || p != null) {
        while (p != null) { //p上面保存的始终都是最新访问到的节点
            arrayList.add(p.val);
            stack.push(p);
            p = p.left;
        }
        if (!stack.empty()) {
            p = stack.pop();
            p = p.right;
        }
    }
    return arrayList;
}

//inorder
ArrayList<Integer> inOrder(TreeNode root) {
    Stack<TreeNode> stack = new Stack<TreeNode>();
    ArrayList<Integer> res = new ArrayList<Integer>();
    TreeNode p = root;
    while (!stack.empty() || p != null) {
        while (p != null) {
            stack.push(p);
            p = p.left;
        }
        if (!stack.empty()) {
            p = stack.pop();
            res.add(p.val);
            p = p.right;
        }
    }
    return res;
}