剑指 Offer 07. 重建二叉树

题目链接：重建二叉树

二叉树的遍历方式

先序遍历：根左右
中序遍历：左根右
后序遍历：左右根
总结：先，中，后指的是遍历根节点的时机

根据遍历序列重建二叉树

只有先序遍历和中序遍历，中序遍历和后序遍历两种方式可以确定一个唯一的二叉树，先序和后序确定的二叉树不唯一。
以此题为例子讲解：先序和中序确定二叉树。

分析：
先序(根，左，右)：[3,9,20,15,7]
中序(左，根，右)：[9,3,15,20,7]
3,一定是根，从中序遍历中找到3（此题题设说明，无重复结点，故可以唯一确定根节点），
3左面的[9]是左子树的节点，3右面的[15,20,7]是右子树。
右子树先序[20，15，7]右子树中序[15,20,7]可得20是右子树的根节点，又可以分为[15][20][7]。

故二叉树如下：

实现

在前序遍历中首节点为根节点，在中序遍历中找到该根节点，将其划分为左子树、根节点、右子树。
再根据中序遍历划分的左右子树节点数目，可以将先序遍历划分为根节点、左子树、右子树。
这样就可以将问题规模进行缩小，左子树和右子树依然可以使用这种方式，也就是分治思想。

//借鉴：Krahets
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    int[] preorder;
    HashMap<Integer,Integer> map = new HashMap();
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        this.preorder = preorder;
        if(preorder == null || inorder == null)  return null;
        //将中序存在HashMap中，可以使查找根节点的效率变为O(1)  
        for(int i = 0;i < inorder.length;i++){
            map.put(inorder[i],i);
        }
        return recur(0,0,inorder.length-1);
    }
    //根节点在前序遍历的索引 root 、子树在中序遍历的左边界 left 、子树在中序遍历的右边界 right 
    TreeNode recur(int root,int left,int right){
        if(left > right)  return null;
        TreeNode node = new TreeNode(preorder[root]);
        // i 就是中序遍历中根节点的索引值
        int i = map.get(preorder[root]);
        //左子树递归
        node.left = recur(root + 1,left,i - 1);
        //右子树递归(i - left) 左子树长度
        node.right = recur(root + (i - left) + 1, i + 1, right);
        return node;
    }
}

递归解法(容易理解)

class Solution {
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        if (preorder.length == 0) return null;
        // [先序遍历]可以直接知道：根节点的值 rootVal
        int rootVal = preorder[0]; // 3
        // 在[中序遍历]中寻找 rootVal 的索引
        int rootIndex = 0;
        for (int i = 0; i < inorder.length; i++) {
            if (inorder[i] == rootVal) {
                rootIndex = i; // 3
                break;
            }
        }
        // 构造根节点
        TreeNode root = new TreeNode(rootVal);
        // 递归
        root.left = buildTree(
                // [9, 6, 10]
                Arrays.copyOfRange(preorder, 1, rootIndex + 1),
                // [6, 9, 10]
                Arrays.copyOfRange(inorder, 0, rootIndex)
        );
        root.right = buildTree(
                // [20, 15, 7]
                Arrays.copyOfRange(preorder, rootIndex + 1, preorder.length),
                // [15, 20, 7]
                Arrays.copyOfRange(inorder, rootIndex + 1, inorder.length)
        );

        return root;
    }
}