根据前中后序遍历数组构建二叉树 - leetcode105，leetcode106， leetcode889

根据前序遍历和中序遍历数组构建二叉树

一道比较经典的leetcode二叉树题目
leetcode105

preorder = [3,9,20,15,7]
inorder = [9,3,15,20,7]

我的想法：观察数组特性，使用递归。prestart与preend是针对preorder数组的范围，instart与inend是针对inorder数组的范围。对于递归的每一层，分别确定好范围，再寻找规律。

比如，对于[20, 15, 7] 与[15, 20, 7]这个范围，根结点为preorder[0]，在inorder数组中找到该数，该数左边是inorder的左子树范围，右边是inorder的右子树范围。根据各自的长度，又可推导出preoder数组中对应的左子树与右子树范围。

这时有人可能存在疑惑，为什么我在inorder中找到的20这个数字一定是root节点呢？因为原题中规定：You may assume that duplicates do not exist in the tree.

以下是我最初的代码：

class Solution {
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        int length = preorder.length;
        if (length == 0) return null;
        TreeNode root = new TreeNode(preorder[0]);
        if (length == 1) return root;
        return helper(preorder, inorder, 0, length, 0, length);
    }
    
    public TreeNode helper(int[] preorder, int[] inorder, int prestart, int preend, int instart, int inend) {
        if (prestart >= preend || instart >= inend || prestart > preorder.length-1 || instart > inorder.length-1) return null;
        TreeNode root = new TreeNode(preorder[prestart]);
        int i;
        for (i = instart; i < inend; i++) {
            if (inorder[i] == preorder[prestart]) break;
        }
        root.left = helper(preorder, inorder, prestart+1, prestart+i-instart+1, instart, i);
        root.right = helper(preorder, inorder, prestart+i-instart+1, preend, i+1, inend);
        return root;
        
    }
}

由于在调试过程中屡次出现index超过range的报错，因此我直接粗暴的把所有报错的可能都添加在退出条件中。这里具体分析一下，哪些是可能出现的，哪些是多余的：

重点看

 root.left = helper(preorder, inorder, prestart+1, prestart+i-instart+1, instart, i);
 root.right = helper(preorder, inorder, prestart+i-instart+1, preend, i+1, inend);

可代入例子考虑，也就是上文举的[20, 15, 7]，[15, 20, 7]，其实退出条件应该就是当前子树没有叶子结点的时候，也就是prestart = preend，instart = inend的时候。

同时思考，我们真的需要prestart、preend、instart、inend全部四个变量吗？
preend这个变量，其实并没有真正参与到递归中，因此，可以省略掉。instart=inend的时候，prestart=preend一定成立，因此这个判断也可去掉。
同时，主函数里对length的判断也可以省略了。

简洁后的代码：

class Solution {
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        int length = preorder.length;
        
        return helper(preorder, inorder, 0, 0, length);
    }
    
    public TreeNode helper(int[] preorder, int[] inorder, int prestart, int instart, int inend) {
        if (instart == inend) return null;
        TreeNode root = new TreeNode(preorder[prestart]);
        int i;
        for (i = instart; i < inend; i++) {
            if (inorder[i] == preorder[prestart]) break;
        }
        root.left = helper(preorder, inorder, prestart+1, instart, i);
        root.right = helper(preorder, inorder, prestart+i-instart+1, i+1, inend);
        return root;
        
    }
}

根据中序遍历和后序遍历数组构建二叉树

leetcode106

inorder = [9,3,15,20,7]
postorder = [9,15,7,20,3]

思路与上一题基本一致，区别只是前一轮的root是通过preorder的第一位先确定的，这一轮则根据postorder的最后一位确定。

class Solution {
    public TreeNode buildTree(int[] inorder, int[] postorder) {
        int length = inorder.length;
        return helper(inorder, postorder, 0, length, 0, length);

    }
    public TreeNode helper(int[] inorder, int[] postorder, int instart, int inend, int poststart, int postend) {
        if (instart == inend || poststart == postend) return null;
        TreeNode root = new TreeNode(postorder[postend-1]);
        int i;
        for (i = instart; i < inend; i++) {
            if (inorder[i] == root.val) break;
        }
        root.left = helper(inorder, postorder, instart, i, poststart, poststart + i - instart);
        root.right = helper(inorder, postorder, i+1, inend, poststart + i - instart, postend - 1);
        return root;
        
    }
}

根据评论区，也可以用hashmap存储inorder的index和value，节省查找时间。

根据前序遍历和后序遍历数组构建二叉树

leetcode889

pre = [1,2,4,5,3,6,7], post = [4,5,2,6,7,3,1]
Output: [1,2,3,4,5,6,7]

前序遍历：[中，左，右]
后序遍历：[左，右，中]
由此可以看出，答案并不唯一。

如何找到左右子树界限？preorder第一位在postorder中找到，就找到了左右子树的界限。比如1，245，367. 再看245、452，此时45可以是左右子树，也可以都在左子树，都在右子树，我们可以假设分别它们是左右子树。

class Solution {
    public TreeNode constructFromPrePost(int[] pre, int[] post) {
        int length = pre.length;
        return helper(pre, post, 0, length, 0, length);
    }
    
    public TreeNode helper(int[] pre, int[] post, int prestart, int preend, int poststart, int postend) {
        if (prestart+1 == preend && poststart+1 == postend) return new TreeNode(pre[prestart]);
        if(poststart>=postend) return null;
        TreeNode root = new TreeNode(pre[prestart]);
        int i;
        for (i = poststart; i < postend; i++) {
            if (post[i] == pre[prestart+1]) break;
        }        
        root.left = helper(pre, post, prestart+1, prestart+2+i-poststart, poststart, i+1);
        root.right = helper(pre, post, prestart+2+i-poststart, preend, i+1, postend-1);

        return root;
    }
}