树的创建以及树的遍历(递归和非递归方法)

分别用递归和非递归方法遍历树。包含前序遍历，中序遍历，后序遍历。本人觉得构建树的方法也很妙，有了这个方法，直接输入数组转化成树，之后测试代码就方便多了。

     //定义树
        function TreeNode (value,left,right) {
            this.value = value;
            this.left = null;
            this.right = null;
        }
        //把数组转化成树
        function arrToTree (arr) {
            var tree = [];
            tree[0] = new TreeNode(arr[0]);//用数组保存结点，之后添加的时候方便查找是哪个结点的子树
            for (var i=1; i < arr.length; i++) {
                tree[i] = new TreeNode(arr[i]);
                if (i % 2 ==1) {
                    if(arr[i] != '') {
                        tree[parseInt((i-1)/2)].left = tree[i];//寻找父节点，并判断是左子树还是右子树
                    } 
                } else {
                    if(arr[i] != '') {
                        tree[parseInt((i-1)/2)].right = tree[i];
                    } 
                } 
            }
            return tree[0];
        }

        //算法1: 前序遍历树
        //参数里面放result是一个很好的不会把result每次清空的办法
        function preOrder (tree,result) {
            if (tree == null) {
                return;
            }
            result.push(tree.value);
            preOrder(tree.left,result);
            preOrder(tree.right,result);
            return result;
        }

        //算法2: 前序遍历树非递归方法
        function preOrder2 (tree) {
            var stack = [];
            var result = [];
            if (tree == null) {
                return;
            }
            stack.push(tree);
            while (stack.length > 0) {
                var node = stack.pop();
                result.push(node.value);
                //注意进栈顺序，跟着算法走一遍看看
                if(node.right != null) {
                    stack.push(node.right);
                }
                if(node.left != null) {
                    stack.push(node.left);
                }
            }
            return result;
        }
        //var tree = arrToTree([1,2,3,4,5,'',6,7,8,9,'','','','','',6]);
        //console.log(preOrder2(tree));

        //算法3: 中序遍历递归方法
        function midOrder (tree,result) {
            if(tree == null) {
                return;
            }
            midOrder (tree.left,result);
            result.push(tree.value);
            midOrder (tree.right,result);
            return result;
        }
        //var tree = arrToTree([1,2,3,4,5,'',6,7,8,9,'','','','','','','',10]);
        //console.log(midOrder(tree,[]));

        //算法4: 中序遍历非递归方法
        function midOrder2 (tree) {
            var stack = [];
            var result = [];
            var node = tree;
            while (stack.length > 0 || node) {
                if (node) {
                    stack.push(node);
                    node = node.left;  
                } else {
                    var node = stack.pop();
                    result.push(node.value);
                    node = node.right;
                } 
            }
            return result;  
        }

        //算法5: 后序遍历递归算法
        function postOrder(tree,result) {
            if (tree == null) {
                return;
            }
            postOrder(tree.left,result);
            postOrder(tree.right,result);
            result.push(tree.value);
            return result;
        }

        //算法6: 后序遍历非递归算法
        function postOrder2(node) {
            var stack = [];
            var result = [];
            stack.push(node);
            while (stack.length > 0) {
                var tmp = stack[stack.length-1];
                if (tmp.left && tmp.left != node && tmp.right != node) {
                    stack.push(tmp.left);
                } else if (tmp.right && tmp.right != node) {
                    stack.push(tmp.right);
                } else {
                    var cnode = stack.pop();
                    result.push(cnode.value);
                    node = tmp;
                }
            }
            return result;      
        }
        var tree = arrToTree([1,2,3,4,5,'',6,7,8,9,'','','','','','','',10]);
        console.log(tree);
        console.log(postOrder2(tree));