【LeetCode】解题105：Construct Binary Tree from Preorder and Inorder Traversal

最新推荐文章于 2021-03-18 16:18:19 发布

原创最新推荐文章于 2021-03-18 16:18:19 发布 · 178 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#二叉树 #leetcode #算法 #java #递归法

LeetCode 专栏收录该内容

56 篇文章

订阅专栏

本文介绍如何使用前序遍历和中序遍历构建二叉树的方法，通过递归查找根节点并划分左右子树，最终实现树的构建。提供了详细的解题思路和Java代码实现。

LeetCode解题 105：Construct Binary Tree from Preorder and Inorder Traversal

Problem 105: Construct Binary Tree from Preorder and Inorder Traversal [Medium]
解题思路
Solution (Java)

Problem 105: Construct Binary Tree from Preorder and Inorder Traversal [Medium]

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

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

For example, given

preorder = [3,9,20,15,7]
inorder = [9,3,15,20,7]

Return the following binary tree:

来源：LeetCode

解题思路

使用前序遍历和中序遍历可以唯一构建一棵二叉树，只需要在中序遍历的数组中找到前序遍历中的根节点，就可以划分左子树和右子树范围，从而递归构建二叉树。

具体过程：

首先构建根节点数值，即preorder[0]：
$r o o t = T r e e N o d e (p r e o r d e r [0])$
然后遍历inorder数组，找到inorder[index] = preorder[0]，index即为根节点在inorder中的下标。
构建左子树的前序遍历和中序遍历数组：
$\\ lChildin = copy(inorder[0],...,inorder[index-1])$
同样可以构建右子树相应的数组：
$\\ rChildin = copy(inorder[index+1],...,inorder[end-1])$
递归构建当前根节点的左右子树：
$\\ root.right = buildTree(rChildpre, rChildin)$

要点：递归

Solution (Java)

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        if(preorder.length < 1) return null;
        if(preorder.length == 1) return new TreeNode(preorder[0]);
        
        int index = 0;
        TreeNode root = new TreeNode(preorder[0]);
        for(int i = 0; i < inorder.length; i++){
            if(inorder[i] == preorder[0]){
                index = i;
                break;
            }
        }
        // left Child
        int[] lChildpre = new int[index];
        System.arraycopy(preorder, 1, lChildpre, 0, index);
        int[] lChildin = new int[index];
        System.arraycopy(inorder, 0, lChildin, 0, index);
        root.left = buildTree(lChildpre, lChildin);

        // right Child
        int rlen = preorder.length - index - 1;
        int[] rChildpre = new int[rlen];
        System.arraycopy(preorder, index + 1, rChildpre, 0, rlen);
        int[] rChildin = new int[rlen];
        System.arraycopy(inorder, index + 1, rChildin, 0, rlen);
        root.right = buildTree(rChildpre, rChildin);

        return root;
    }
}