力扣hot100 前序、中序、后序组合遍历序列构造二叉树 打卡

106. 从中序与后序遍历序列构造二叉树

根据一棵树的中序遍历与后序遍历构造二叉树。

注意:
你可以假设树中没有重复的元素。

例如，给出

中序遍历 inorder = [9,3,15,20,7]
后序遍历 postorder = [9,15,7,20,3]

返回如下的二叉树：

    3
   / \
  9  20
    /  \
   15   7

                                                                       前序遍历：

中序遍历： 

后序遍历

解题思路：其实不管是怎么组合，都是先找左子树和右子树的分界点，先中、后中是一种找法，先后是另一种找法，都是利用了先中后遍历的性质。

第一步：寻找当前根节点
这一部分总的来说是在寻找可以将左右子树划分开的根节点

前+后
首先我们可以显然知道当前根节点为pre[pre_start],并且它在后序中的位置为post_end，因此这里我们需要找到能区分左右子树的节点。
我们知道左子树的根节点为pre[pre_start+1]，因此只要找到它在后序中的位置就可以分开左右子树（index的含义）
前+中
首先我们可以显然知道当前根节点为pre[pre_start],只用找出它在中序中的位置，就可以把左右子树分开（index的含义）
中+后
首先我们可以显然知道当前根节点为post[post_end]，只用找出它在中序中的位置，就可以把左右子树分开（index的含义）

第二步：寻找左右遍历范围，也就是找出左右子树的数组随后进行递归

这一部分运用了一个技巧是 “两种遍历中，同一子树的节点数目是相同的”
需要说明的是在"前+后","前+中"我们都运用到了“右子树起始位置为左子树终止位置+1”，其实这个也可以运用上面这个技巧来计算出起始位置

前+后
后序遍历中，我们知道 左子树：[post_start,index], 右子树：[index+1, post_end-1]
在前序遍历中，左子树起始位置为pre_start+1,左子树个数一共有(index - post_start)个，因此左子树：[pre_start+1, pre_start+1 + (index - post_start)]
右子树起始位置为左子树终止位置+1，终止位置为pre_end，因此右子树：[ pre_start+1 + (index - post_start) + 1, pre_end]
前+中
中序遍历中，我们知道 左子树：[inorder_start,index-1], 右子树：[index+1, inorder_end]
在前序遍历中，左子树起始位置为pre_start+1,左子树一共有(index-1 - inorder_start)个，因此左子树：[pre_start+1, pre_start+1 + (index-1 - inorder_start)]
右子树起始位置为左子树终止位置+1，终止位置为pre_end，因此右子树：[ pre_start+1 + (index-1 - inorder_start) + 1, pre_end]
中+后
中序遍历中，我们知道 左子树：[inorder_start,index-1], 右子树：[index+1, inorder_end]
在后序遍历中，左子树起始位置为post_start，左子树一共有(index-1 - inorder_start)个，因此左子树：[post_start, post_start + (index-1 - inorder_start)]
右子树的终止位置为post_end - 1,右子树一共有(inorder_end - (index+1))个,因此右子树:[post_end - 1 - (inorder_end - (index+1)), post_end - 1]

三种类型的题目的代码见下图：

先序遍历+中序遍历

/**
先序遍历+中序遍历
 */
class Solution {
    HashMap<Integer,Integer> map = new HashMap();
    public TreeNode buildTree(int[] preorder, int[] inorder) {     
        for(int i = 0 ; i < inorder.length ; i++){
            map.put(inorder[i],i);
        }
        return dfs(preorder,inorder,0,preorder.length-1,0,inorder.length-1);
    }

    private TreeNode dfs(int[] preorder, int[] inorder , int lp , int rp , int li , int ri){
        if(lp > rp){
            return null;
        }
        TreeNode node = new TreeNode(preorder[lp]);
        int index = map.get(node.val);
        int lsize = index - li;
        int rsize = ri - index;
        //先序的左子树[lp + 1 ,lp + lsize] 右子树[lp + lsize + 1,rp]
        //中序的左子树[li , index - 1] 右子树[index + 1 ,ri]
        node.left = dfs(preorder,inorder,lp + 1,lp + lsize,li,index - 1);
        node.right = dfs(preorder,inorder,lp + lsize + 1,rp,index + 1,ri);
        return node;
    }
}

后序遍历+中序遍历

/**
中序遍历+后序遍历
 */
class Solution {
    HashMap<Integer,Integer> map = new HashMap();
    public TreeNode buildTree(int[] inorder, int[] postorder) {
        for(int i = 0 ; i < inorder.length ; i++){
            map.put(inorder[i],i);        
        }
        return dfs(inorder,postorder,0,inorder.length-1,0,postorder.length-1);
    }

    private TreeNode dfs(int[] inorder, int[] postorder,int li,int ri,int lp,int rp){
        if(li > ri){
            return null;
        }
        
        TreeNode node = new TreeNode(postorder[rp]);
        if(li == ri){
            return node;
        }
        int index = map.get(node.val);
        int lsize = index - li;
        int rsize = ri - index;
        node.left = dfs(inorder,postorder,li,index-1,lp,lp+lsize-1);
        node.right = dfs(inorder,postorder,index+1,ri,lp+lsize,rp-1);
        return node;
    }
}

先序遍历+后序遍历

class Solution {
    HashMap<Integer,Integer> map = new HashMap();
    public TreeNode constructFromPrePost(int[] preorder, int[] postorder) {
        for(int i = 0 ; i < postorder.length ; i++){
            map.put(postorder[i],i);
        }
        return dfs(preorder,postorder,0,preorder.length-1,0,postorder.length-1);   
    }
    private TreeNode dfs(int[] preorder, int[] postorder,int lpre,int rpre,int lpost,int rpost){
        if(lpre > rpre || lpost > rpost){
            return null;
        }
        TreeNode node = new TreeNode(preorder[lpre]);
        if(lpre == rpre){
            return node;
        }
        int temp = preorder[lpre+1];
        int index = map.get(temp);
        int lsize = index - lpost;
        node.left = dfs(preorder,postorder,lpre+1,lpre+1+lsize,lpost,index);
        node.right = dfs(preorder,postorder,lpre+lsize+2,rpre,index+1,rpost-1);
        return node;
    } 
}

总结：

三种构造方式是一种模板套路。