94 & 144 & 145.前、中、后序遍历二叉树

144. Binary Tree Preorder Traversal

先序遍历二叉树
有栈和递归两种办法：
栈（深度优先遍历二叉树）

var preorderTraversal = function(root) {
    var res = [];
    if (root) {
        var s = [root];
        while(s.length!==0) {
            var temp = s.pop();
            res.push(temp.val);
            if (temp.right)
                s.push(temp.right);
            if (temp.left)
                s.push(temp.left);
        }
    }
    return res;
};

递归：

var preorderTraversal = function(root) {
    var res = [];
    if (root) {
        var help = function(root) {
            res.push(root.val);
            if (root.left)
                help(root.left);
            if (root.right)
                help(root.right);
        }
        help(root);
    }
    return res;
};

94. Binary Tree Inorder Traversal

中序遍历二叉树
使用了递归的话会很简单就得到解决方案

var inorderTraversal = function(root) {
    var record = [];
    if (root) {
        var help = function(root) {
            if (root.left)
                help(root.left);
            record.push(root.val);
            if (root.right)
                help(root.right);
        };
        help(root);
    }
    return record;
};

如果不用递归而使用栈呢，这样就需要一点处理了：
对于当前节点来说，如果它有左节点那就意味着当前节点并不是现在应该遍历到的节点，压到栈里，然后继续寻找它的左节点。
如果木有左节点了，首先，现在这个节点就是要遍历的节点，把节点值放到结果数组里，这个节点如果有右节点，把右节点压到栈里，顺着右节点的左节点往下找。

var inorderTraversal = function(root) {
    var res = [];
    if (root) {
        var s = [];
        s.push(root);
        var left = root.left;
        while(s.length!==0) {
            if (left!==null) {
                s.push(left);
                left = left.left;
            } else {
                var temp = s.pop();
                res.push(temp.val);
                if (temp.right){
                    s.push(temp.right);
                    left = temp.right.left;
                }
            }
        }
    }
    return res;
};

145. Binary Tree Postorder Traversal

后序遍历二叉树
使用递归还是很简单：

var postorderTraversal = function(root) {
    var res = [];
    var help = function(root) {
        if (root.left) 
            help(root.left);
        if (root.right) 
            help(root.right);
        res.push(root.val);
    };
    if (root) 
        help(root);
    return res;
};

使用栈，和中序遍历差不多的思想：
对于当前节点来说，如果它有左节点那就意味着当前节点并不是现在应该遍历到的节点，压到栈里，然后继续寻找它的左节点。
如果木有左节点了，就找栈里的最后一个元素看有没有右节点，如果有右节点，把右节点压到栈里，对这个节点做一个标记，顺着右节点的左节点往下找。
如果栈里的最后一个元素没有子节点，就该往外弹了，如果这个节点是个左节点，直接弹就好，如果是个右节点，弹完它还得把它的父节点弹出来。

var postorderTraversal = function(root) {
    var res = [];
    if (root) {
        var s = [root];
        var left = root.left;
        while(s.length!==0) {
            if (left) {
                s.push(left);
                left = left.left;
            } else {
                var temp = s[s.length - 1];
                if (temp.right) {
                    temp.right.flag = true;
                    s.push(temp.right);
                    left = temp.right.left;
                } else {
                    temp = s.pop();
                    while (temp.flag) {
                        res.push(temp.val);
                        temp = s.pop();
                    }
                    res.push(temp.val);
                }
            }
        }
    }
    return res;
};