LeetCode105. Construct Binary Tree from Preorder and Inorder Traversal

最新推荐文章于 2024-01-17 14:50:43 发布

nianhua120

最新推荐文章于 2024-01-17 14:50:43 发布

阅读量242

点赞数

CC 4.0 BY-SA版权

分类专栏：算法文章标签： leetcode 分治前序中序

本文链接：https://blog.youkuaiyun.com/nianhua120/article/details/52118238

算法专栏收录该内容

83 篇文章

订阅专栏

本文介绍如何根据前序遍历和中序遍历构建二叉树的方法。通过分治思想，利用前序遍历的第一个元素作为根节点，划分中序遍历序列，并递归构建左右子树。介绍了两种实现方式及其时间复杂度。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Given preorder and inorder traversal of a tree, construct the binary tree.

Note:

You may assume that duplicates do not exist in the tree.

这种类型的题目经常考选择题。对于这道题，采用的是分治的思想，通过preorder的第一个元素为根元素，将inorder分成两部分，也将preorder分成两部分。这样每个部分又是相同的子问题。解决完这两个子问题，就是得到了当前结点的左右子树，将其合并即可。

public class Solution {
    private TreeNode partitionalMerge(int[] preorder, int pS, int pE, int[] inorder ,int iS, int iE){
        if(pS >pE || iS > iE) return null;
        if(pS == pE) return new TreeNode(preorder[pS]);
        int mid = 0;
        for(mid =iS; mid<=iE; mid++){
            if(inorder[mid] == preorder[pS])break;
        }
                
        TreeNode left = partitionalMerge(preorder, pS+1, pS+mid-iS, inorder, iS, mid-1);
        TreeNode right = partitionalMerge(preorder, pS+mid-iS+1, pE, inorder, mid+1, iE);
        TreeNode root = new TreeNode(preorder[pS]);
        root.left = left;
        root.right = right;
        return root;
    }
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        if(preorder.length != inorder.length) return null;//exception
        if(preorder == null) return null;
        return partitionalMerge(preorder, 0, preorder.length-1, inorder, 0, inorder.length-1);
    }
}

难度是索引坐标经常算错。这道题的最坏时间复杂度为O（NLogN），空间复杂度为O（LogN+N），其中N为数组长度， LogN为递归占用空间，N为树所用的节点空间。

时间复杂度中的N为搜索的最坏时间，那么如果我们将搜索算法修改让其时间复杂度为O（1），这样整体的时间复杂度为O(N)。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    private TreeNode partitionalMerge(int[] preorder, int pS, int pE ,int iS, int iE, HashMap<Integer, Integer> map){
        if(pS >pE || iS > iE) return null;
        if(pS == pE) return new TreeNode(preorder[pS]);
        int mid = 0;
        mid =map.get(preorder[pS]);
                
        TreeNode left = partitionalMerge(preorder, pS+1, pS+mid-iS, iS, mid-1, map);
        TreeNode right = partitionalMerge(preorder, pS+mid-iS+1, pE, mid+1, iE, map);
        TreeNode root = new TreeNode(preorder[pS]);
        root.left = left;
        root.right = right;
        return root;
    }
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        if(preorder.length != inorder.length) return null;//exception
        if(preorder == null) return null;
        HashMap<Integer, Integer> map = new HashMap<>();
        for(int i = 0; i<inorder.length; i++){
            map.put(inorder[i], i);
        }
        return partitionalMerge(preorder, 0, preorder.length-1, 0, inorder.length-1, map);
    }
}

计算时间从20多ms降低到了6ms。