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

最新推荐文章于 2024-01-17 14:50:43 发布
最新推荐文章于 2024-01-17 14:50:43 发布
阅读量496 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： LeetCode 文章标签： leetcode tree array dfs
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/u011863024/article/details/117912485
本文介绍了一种高效的算法，用于根据预序遍历和中序遍历构建二叉树。方法三是基于映射的优化解法，避免了暴力查找，显著提高了性能。通过示例和测试用例展示了如何应用此方法解决LeetCode问题。

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

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));
	}
}
C++版-剑指offer 面试题6：重建二叉树(Leetcode105. Construct Binary Tree from Preorder and Inorder Traversal) 解题报告
极客学长Bravo | 突破信息差 | 副业生财有术
04-23 3348
剑指offer 重建二叉树 参与人数：5246  时间限制：1秒  空间限制：32768K 题目描述 输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。 分析
Construct Binary Tree from Preorder and Inorder Traversal
10-24
Construct Binary Tree from Preorder and Inorder Traversal 根据先序，中序建立二叉树
105.construct binary tree from preorder and inorder traversal从前序和与中序遍历序列构造二叉树【LeetCode单题讲解系列】
08-31
105.construct_binary_tree_from_preorder_and_inorder_traversal从前序
【LeetCode 面试经典150题】105. Construct Binary Tree from Preorder and Inorder Traversal 从前序和中序构造二叉树
qq_43513394的博客
01-17 405
Given two integer arrays and where is the preorder traversal of a binary tree and is the inorder traversal of the same tree, construct and return the binary tree.给定两个整数数组 和 ，其中 是二叉树的前序遍历，而 是同一棵树的中序遍历，根据这两个数组构造并返回这棵二叉树。输入: = [3,9,20,15,7], = [9,3,1
四平方和定理leetcode-leetcode-practice:个人LeetCode练习代码
06-30
105.construct-binary-tree-from-preorder-and-inorder-traversal (从前序与中序遍历序列构造二叉树) 106.construct-binary-tree-from-inorder-and-postorder-traversal (从中序与后序遍历序列构造二叉树) 112.path-...
Leetcode 使用 Javascript 的解决方案.zip
最新发布
11-25
Javascript 的解决方案Leetcode Problems and interview problems in Javascript10 Regular Expresion Matching.js100 Same Tree.js101 Symmetric Tree.js102 Binary Tree Level Order Traversal.js103 Binary Tree ...
LeetCode Construct Binary Tree from Preorder and Inorder Traversal
DRFish
02-17 1544
通过一棵二叉树的前序和中序排列来得出它的树形结构。
LeetCode——Construct Binary Tree from Preorder and Inorder Traversal
三分地
09-14 2200
Given preorder and inorder traversal of a tree, construct the binary tree. Note: You may assume that duplicates do not exist in the tree. 原题链接：https://oj.leetcode.com/problems/construct-binary-
105. Construct Binary Tree from Preorder and Inorder Traversal
GGGGITFKBJG的主页
12-30 116
105. 从前序与中序遍历序列构造二叉树 根据一棵树的前序遍历与中序遍历构造二叉树。 注意: 你可以假设树中没有重复的元素。 例如，给出 前序遍历 preorder =[3,9,20,15,7] 中序遍历 inorder = [9,3,15,20,7] 返回如下的二叉树： 3 / \ 9 20 / \ 15 7 解法一： //时间复杂度O(n), 空...
leetcode热题100刷题顺序
03-30
1. Two Sum 2. Add Two Numbers 3. Longest Substring Without Repeating Characters 4. Median of Two Sorted Arrays 5. Longest Palindromic Substring 6. ZigZag Conversion 7. Reverse Integer 8. String to Integer (atoi) 9. Palindrome Number 10. Regular Expression Matching 11. Container With Most Water 12. Integer to Roman 13. Roman to Integer 14. Longest Common Prefix 15. 3Sum 16. 3Sum Closest 17. Letter Combinations of a Phone Number 18. 4Sum 19. Remove Nth Node From End of List 20. Valid Parentheses 21. Merge Two Sorted Lists 22. Generate Parentheses 23. Swap Nodes in Pairs 24. Reverse Nodes in k-Group 25. Remove Duplicates from Sorted Array 26. Remove Element 27. Implement strStr() 28. Divide Two Integers 29. Substring with Concatenation of All Words 30. Next Permutation 31. Longest Valid Parentheses 32. Search in Rotated Sorted Array 33. Search for a Range 34. Find First and Last Position of Element in Sorted Array 35. Valid Sudoku 36. Sudoku Solver 37. Count and Say 38. Combination Sum 39. Combination Sum II 40. First Missing Positive 41. Trapping Rain Water 42. Jump Game 43. Merge Intervals 44. Insert Interval 45. Unique Paths 46. Minimum Path Sum 47. Climbing Stairs 48. Permutations 49. Permutations II 50. Rotate Image 51. Group Anagrams 52. Pow(x, n) 53. Maximum Subarray 54. Spiral Matrix 55. Jump Game II 56. Merge k Sorted Lists 57. Insertion Sort List 58. Sort List 59. Largest Rectangle in Histogram 60. Valid Number 61. Word Search 62. Minimum Window Substring 63. Unique Binary Search Trees 64. Unique Binary Search Trees II 65. Interleaving String 66. Maximum Product Subarray 67. Binary Tree Inorder Traversal 68. Binary Tree Preorder Traversal 69. Binary Tree Postorder Traversal 70. Flatten Binary Tree to Linked List 71. Construct Binary Tree from Preorder and Inorder Traversal 72. Construct Binary Tree from Inorder and Postorder Traversal 73. Binary Tree Level Order Traversal 74. Binary Tree Zigzag Level Order Traversal 75. Convert Sorted Array to Binary Search Tree 76. Convert Sorted List to Binary Search Tree 77. Recover Binary Search Tree 78. Sum Root to Leaf Numbers 79. Path Sum 80. Path Sum II 81. Binary Tree Maximum Path Sum 82. Populating Next Right Pointers in Each Node 83. Populating Next Right Pointers in Each Node II 84. Reverse Linked List 85. Reverse Linked List II 86. Partition List 87. Rotate List 88. Remove Duplicates from Sorted List 89. Remove Duplicates from Sorted List II 90. Intersection of Two Linked Lists 91. Linked List Cycle 92. Linked List Cycle II 93. Reorder List 94. Binary Tree Upside Down 95. Binary Tree Right Side View 96. Palindrome Linked List 97. Convert Binary Search Tree to Sorted Doubly Linked List 98. Lowest Common Ancestor of a Binary Tree 99. Lowest Common Ancestor of a Binary Search Tree 100. Binary Tree Level Order Traversal II
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值