LeetCode - Medium - 105. Construct Binary Tree from Preorder and Inorder Traversal

Topic

• Array
• Tree
• Depth-first Search

Description

https://leetcode.com/problems/construct-binary-tree-from-preorder-and-inorder-traversal/

Given two integer arrays preorder and inorder where preorder is the preorder traversal of a binary tree and inorder is the inorder traversal of the same tree, construct and return the binary tree.

Example 1:

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

Example 2:

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

Constraints:

• 1 <= preorder.length <= 3000
• inorder.length == preorder.length
• -3000 <= preorder[i], inorder[i] <= 3000
• preorder and inorder consist of unique values.
• Each value of inorder also appears in preorder.
• preorder is guaranteed to be the preorder traversal of the tree.
• inorder is guaranteed to be the inorder traversal of the tree.

Analysis

核心解法：

The basic idea is here:
Say we have 2 arrays, PRE and IN.
Preorder traversing implies that PRE[0] is the root node.
Then we can find this PRE[0] in IN, for example, say it’s IN[5].
Now we know that IN[5] is root, so we know that IN[0] - IN[4] is on the left side, IN[6] to the end is on the right side.
Recursively doing this on subarrays, we can build a tree out of it 😃
Link

方法一：我写的，提交给系统，所有测试例子通过，但报超时。

方法二：方法一的改进版，使用map代替暴力查找，提交给系统，虽接受，但很耗时。

方法三：别人写的，方法二的preMap没必要，方法二的还有nextPreEnd变量可通过“前序遍历一棵二叉树后得到得序列的个数与中序遍历一棵二叉树后得到得序列的个数一致”特性和加减法便可简易求得，（方法二的nextPreEnd自己搞复杂了。）

Submission

import java.util.HashMap;
import java.util.Map;

import com.lun.util.BinaryTree.TreeNode;

public class ConstructBinaryTreeFromPreorderAndInorderTraversal {
	
	//方法一：我写的，提交给系统，报超时
    public TreeNode buildTree(int[] preorder, int[] inorder) {
    	return buildTree(preorder, 0, preorder.length - 1, inorder, 0, inorder.length - 1);
    }
    
    private TreeNode buildTree(int[] preorder, int preStart, int preEnd, // 
    		 int[] inorder, int inStart, int inEnd) {
    
    	if(preStart > preEnd) return null;
    	
    	TreeNode parent = new TreeNode(preorder[preStart]);
    	
    	//find parent's value in inorder sequence
    	int parentIndexInInorder = findIndex(inorder, parent.val, inStart, inEnd);

    	//在preorder找出最右边界，为下回递归作准备
    	int nextPreEnd = preStart;
    	for(int i = inStart; i <= parentIndexInInorder - 1; i++) {
    		int index = findIndex(preorder, inorder[i], preStart + 1, preEnd);
    		nextPreEnd = Math.max(nextPreEnd, index);
    	}
    	
    	parent.left = buildTree(preorder, preStart + 1, nextPreEnd, // 
    			inorder, inStart, parentIndexInInorder - 1);
    	parent.right = buildTree(preorder, nextPreEnd + 1, preEnd, 
    			inorder, parentIndexInInorder + 1, inEnd);
    	
    	return parent;
    }    
    
    private int findIndex(int[] array, int targetValue, int start, int end) {    	
    	if(start > end)
    		return -1;
    	for(int i = start; i <= end; i++) {
    		if(array[i] == targetValue)
    			return i;
    	}
    	return -1;
    }
    
    
    //方法二：方法一的改进版，使用map代替暴力查找，提交给系统，虽接受，但很耗时
    public TreeNode buildTree2(int[] preorder, int[] inorder) {
    	Map<Integer, Integer> preMap = makeValue2IndexMap(preorder);
    	Map<Integer, Integer> inMap = makeValue2IndexMap(inorder);
    	return buildTree2(preorder, preMap, 0, preorder.length - 1,// 
    			inorder, inMap, 0, inorder.length - 1);
    }
    
    private TreeNode buildTree2(int[] preorder, Map<Integer, Integer> preMap, int preStart, int preEnd, // 
   		 int[] inorder, Map<Integer, Integer> inMap,  int inStart, int inEnd) {
   
	   	if(preStart > preEnd) return null;
	   	
	   	TreeNode parent = new TreeNode(preorder[preStart]);
	   	
	   	//find parent's value in inorder sequence
	   	int parentIndexInInorder = inMap.getOrDefault(parent.val, -1);
	
	   	//在preorder找出最右边界，为下回递归作准备
	   	int nextPreEnd = preStart;
	   	for(int i = inStart; i <= parentIndexInInorder - 1; i++) {
	   		int index = preMap.getOrDefault(inorder[i], -1);
	   		nextPreEnd = Math.max(nextPreEnd, index);
	   	}
	   	
	   	parent.left = buildTree2(preorder, preMap, preStart + 1, nextPreEnd, // 
	   			inorder, inMap, inStart, parentIndexInInorder - 1);
	   	parent.right = buildTree2(preorder, preMap, nextPreEnd + 1, preEnd, 
	   			inorder, inMap, parentIndexInInorder + 1, inEnd);
	   	
	   	return parent;
    }
    
    private Map<Integer, Integer> makeValue2IndexMap(int[] array){
    	Map<Integer, Integer> map = new HashMap<>();
    	for(int i = 0; i < array.length; i++)
    		map.put(array[i], i);
    	return map;
    }
    
    
    //方法三：别人写，性能颇佳
    public TreeNode buildTree3(int[] preorder, int[] inorder) {
        Map<Integer, Integer> inMap = new HashMap<>();

        for(int i = 0; i < inorder.length; i++)
            inMap.put(inorder[i], i);

        TreeNode root = buildTree3(preorder, 0, preorder.length - 1, inorder, 0, inorder.length - 1, inMap);
        return root;
    }

    public TreeNode buildTree3(int[] preorder, int preStart, int preEnd, int[] inorder, int inStart, int inEnd, Map<Integer, Integer> inMap) {
        if(preStart > preEnd || inStart > inEnd) return null;

        TreeNode root = new TreeNode(preorder[preStart]);
        int inRoot = inMap.get(root.val);
        int numsLeft = inRoot - inStart;

        root.left = buildTree3(preorder, preStart + 1, preStart + numsLeft, inorder, inStart, inRoot - 1, inMap);
        root.right = buildTree3(preorder, preStart + numsLeft + 1, preEnd, inorder, inRoot + 1, inEnd, inMap);

        return root;
    }
    
}

Test

import static org.junit.Assert.*;
import org.junit.Test;

import com.lun.util.BinaryTree;
import com.lun.util.BinaryTree.TreeNode;

public class ConstructBinaryTreeFromPreorderAndInorderTraversalTest {

	@Test
	public void test() {
		ConstructBinaryTreeFromPreorderAndInorderTraversal obj = new ConstructBinaryTreeFromPreorderAndInorderTraversal();

		TreeNode actual1 = obj.buildTree(new int[] {3,9,20,15,7}, new int[] {9,3,15,20,7});
		TreeNode expected1 = BinaryTree.integers2BinaryTree(3,9,20,null,null,15,7);
		assertTrue(BinaryTree.equals(actual1, expected1));
		
		TreeNode actual2 = obj.buildTree(new int[] {-1}, new int[] {-1});
		TreeNode expected2 = BinaryTree.integers2BinaryTree(-1);
		assertTrue(BinaryTree.equals(actual2, expected2));
	}
	
	@Test
	public void test2() {
		ConstructBinaryTreeFromPreorderAndInorderTraversal obj = new ConstructBinaryTreeFromPreorderAndInorderTraversal();
		
		TreeNode actual1 = obj.buildTree2(new int[] {3,9,20,15,7}, new int[] {9,3,15,20,7});
		TreeNode expected1 = BinaryTree.integers2BinaryTree(3,9,20,null,null,15,7);
		assertTrue(BinaryTree.equals(actual1, expected1));
		
		TreeNode actual2 = obj.buildTree2(new int[] {-1}, new int[] {-1});
		TreeNode expected2 = BinaryTree.integers2BinaryTree(-1);
		assertTrue(BinaryTree.equals(actual2, expected2));
	}
	
	@Test
	public void test3() {
		ConstructBinaryTreeFromPreorderAndInorderTraversal obj = new ConstructBinaryTreeFromPreorderAndInorderTraversal();
		
		TreeNode actual1 = obj.buildTree3(new int[] {3,9,20,15,7}, new int[] {9,3,15,20,7});
		TreeNode expected1 = BinaryTree.integers2BinaryTree(3,9,20,null,null,15,7);
		assertTrue(BinaryTree.equals(actual1, expected1));
		
		TreeNode actual2 = obj.buildTree3(new int[] {-1}, new int[] {-1});
		TreeNode expected2 = BinaryTree.integers2BinaryTree(-1);
		assertTrue(BinaryTree.equals(actual2, expected2));
	}
}