分治+构建树

虽然说是分治，但本质还是语义。语义永远是第一，分治的话考虑相对位置就完事了

https://leetcode-cn.com/problems/construct-binary-tree-from-preorder-and-inorder-traversal/solution/yi-pian-ti-jie-gao-ding-qian-xu-zhong-xu-h3tm/
思路：前序的第一个就是根节点，不要想着怎么递推，要有递归思维(虽然是数组)
以它建树，.......，返回它。中间自然就是建立左右子树的过程
左右子树就是纯纯的划分范围了，根据语义来：左子树在先序是怎样，左子树在中序是怎样
很快我们就发现只需要一个长度(左子树的长度)，就可以确定所有的范围
map的话既然要取得是下标 那么存的v自然也是下标

写的时候建立好这么一个表

前后的特殊情况

因为不像其他两种一样，直接可以拿到分界的，而是需要在pre的第一个往后找，pre[first+1]
所以这个+1操作需要判断
不然很直接 [1]的树都会出错

前中

class Solution {
    //分治 
    //语义是 [a,b]那么就要根据这个来
    Map<Integer,Integer> map = new HashMap<>();
    public TreeNode buildTree(int[] pre, int[] mid) {
        //把逻辑捋清楚再说
        for(int i = 0; i<mid.length; i++){
            //我们是想要下标 所以这里v是i
            map.put(mid[i],i);
        }
        return build(pre,0,pre.length-1,0,pre.length-1);
    }
    //分治一定是相对位置
    private TreeNode build(int[] pre, int p_a, int p_b, int m_a, int m_b){
        //我们只用pre
        if(p_a > p_b || m_a > m_b) return null;
        //p不需要mid
        //int p_mid = (p_a + p_b) / 2;
        int m_mid = map.get(pre[p_a]);
        TreeNode root = new TreeNode(pre[p_a]);
        //要把左半部分长度求出来
        int lenl = m_mid - m_a;
        //一个长度就狗了
        //int lenr = m_b - m_mid;
        root.left = build(pre,p_a+1,p_a+lenl,m_a,m_mid-1);
        root.right = build(pre,p_a+1+lenl,p_b,m_mid+1,m_b);
        return root;
    }
}

中后

基本一样 注意边界

class Solution {
    Map<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 build(postorder,0,inorder.length-1,0,inorder.length-1);
    }
    private TreeNode build(int[] post,int m_a, int m_b, int h_a, int h_b){
        if(m_a > m_b || h_a > h_b) return null;
        int tar = post[h_b];
        int mid = map.get(tar);
        //找长度 不难 
        int len = mid-m_a;
        TreeNode root = new TreeNode(tar);
        root.left = build(post,m_a,mid-1,h_a,h_a+len-1);
        root.right =build(post,mid+1,m_b,h_a+len,h_b-1) ;
        return root;
    }
}

前后

class Solution {
    Map<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 build(preorder,0,postorder.length-1,0,postorder.length-1);
    }
    //按常规的写一写
    private TreeNode build(int[] pre,int p_a,int p_b,int w_a,int w_b){
        if(p_a > p_b || w_a > w_b) return null;
        //按index来
        TreeNode root = new TreeNode(pre[p_a]);
        if(p_a+1 > p_b) return root;
        int index = map.get(pre[p_a+1]);
        int len = index - w_a+1;
        root.left = build(pre, p_a+1, p_a+len, w_a, index);
        root.right = build(pre, p_a+len+1, p_b, index+1, w_b-1);
        return root; 
    }
}