前序中序构造二叉树——分治

题目描述

给定一棵树的前序遍历 preorder 与中序遍历  inorder。请构造二叉树并返回其根节点。

示例 1:

Input: preorder = [3,9,20,15,7], inorder = [9,3,15,20,7]
Output: [3,9,20,null,null,15,7]

示例 2:

Input: preorder = [-1], inorder = [-1]
Output: [-1]

 思路

在找到根节点后，可以把构造二叉树的任务分解成构造左二叉子树与右二叉子树。分治的思路有了，重点是寻找到左子树与右子树的前序中序数组，利用递归即可解决。

前序按照[ 根节点, [左子树的前序遍历结果], [右子树的前序遍历结果] ]的顺序遍历，因此前序数组头部一定是根节点。

中序按照[ [左子树的中序遍历结果], 根节点, [右子树的中序遍历结果] ]的顺序遍历，中序根节点左右就是左右子树，根据前序的头部元素的下标就可以将中序数组分成三部分：左中序数组、根节点、右中序数组。同样的，获取左中序数组的长度后可以把前序数组也给分开。

代码实现

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
public class Solution {
    //获取数组指定元素的下标
    public int getIndex(int[] arr,int value){
        for(int i=0;i<arr.length;i++){
            if(arr[i] == value)
                return i;
        }
        return -1;
    }

    /**
     * 递归的构建二叉树
     * @param preorder 前序数组
     * @param inorder 中序数组
     * @param preL  截取前序左下标
     * @param preR  截取前序右下标
     * @param inL   截取中序左下标
     * @param inR   截取中序右下标
     * @return  根节点
     */
    public TreeNode myBuildTree(int[] preorder,int[] inorder,int preL,int preR,int inL,int inR){
        if(preL > preR){
            return null;
        }else if(preL == preR){
            return new TreeNode(preorder[preL]);
        }else{
            int rootIndex = getIndex(inorder,preorder[preL]);
            int leftSize = rootIndex - inL;//左子树数组长度
//左子树前序[preL+1,preL+左子树长度]、中序[inL,根节点下标-1]
            TreeNode left = myBuildTree(preorder,inorder,preL+1,preL+leftSize,inL,rootIndex-1);
//右子树前序[左子树的末尾+1,preR]、中序[根节点下标+1,inR]
            TreeNode right = myBuildTree(preorder,inorder,preL+leftSize+1,preR,rootIndex+1,inR);
            return new TreeNode(preorder[preL],left,right);
        }
    }

    public TreeNode buildTree(int[] preorder, int[] inorder) {
        return myBuildTree(preorder,inorder,0,preorder.length-1,0,inorder.length-1);
    }
}

 复杂度分析与改进

我们把原问题分解成两个子问题，每个子问题的规模为n/2，同时分解的过程中花费了n的线性时间用于查找下标，可以写出时间复杂度T(n)的递归式：

根据主定理可以得到时间复杂度T(n)=nlgn，为了降低时间复杂度，

可以考虑使用哈希表来帮助我们快速地定位根节点。对于哈希映射中的每个键值对，键表示一个元素（节点的值），值表示其在中序遍历中的出现位置。在构造二叉树的过程之前，我们可以对中序遍历的列表进行一遍扫描，就可以构造出这个哈希映射。在此后构造二叉树的过程中，我们就只需要 O(1)的时间对根节点进行定位了。