12.3   Building binary tree problem

Question

Given the preorder traversal preorder and inorder traversal inorder of a binary tree, construct the binary tree and return the root node of the binary tree. Assume that there are no duplicate values in the nodes of the binary tree (as shown in the diagram below).

Figure 12-5   Example data for building a binary tree

1.   Determining if it is a divide and conquer problem

The original problem of constructing a binary tree from preorder and inorder is a typical divide and conquer problem.

• The problem can be decomposed: From the perspective of divide and conquer, we can divide the original problem into two subproblems: building the left subtree and building the right subtree, plus one operation: initializing the root node. For each subtree (subproblem), we can still use the above division method, dividing it into smaller subtrees (subproblems), until the smallest subproblem (empty subtree) is reached.
• The subproblems are independent: The left and right subtrees are independent of each other, with no overlap. When building the left subtree, we only need to focus on the parts of the inorder and preorder traversals that correspond to the left subtree. The same applies to the right subtree.
• Solutions to subproblems can be combined: Once the solutions for the left and right subtrees (solutions to subproblems) are obtained, we can link them to the root node to obtain the solution to the original problem.

2.   How to divide the subtrees

Based on the above analysis, this problem can be solved using divide and conquer, but how do we use the preorder traversal preorder and inorder traversal inorder to divide the left and right subtrees?

By definition, preorder and inorder can be divided into three parts.

• Preorder traversal: [ Root | Left Subtree | Right Subtree ], for example, the tree in the diagram corresponds to [ 3 | 9 | 2 1 7 ].
• Inorder traversal: [ Left Subtree | Root | Right Subtree ], for example, the tree in the diagram corresponds to [ 9 | 3 | 1 2 7 ].

Using the data in the diagram above, we can obtain the division results as shown in the steps below.

1. The first element 3 in the preorder traversal is the value of the root node.
2. Find the index of the root node 3 in inorder, and use this index to divide inorder into [ 9 | 3 ｜ 1 2 7 ].
3. Based on the division results of inorder, it is easy to determine the number of nodes in the left and right subtrees as 1 and 3, respectively, thus dividing preorder into [ 3 | 9 | 2 1 7 ].

Figure 12-6   Dividing the subtrees in preorder and inorder traversals

3.   Describing subtree intervals based on variables

Based on the above division method, we have now obtained the index intervals of the root, left subtree, and right subtree in preorder and inorder. To describe these index intervals, we need the help of several pointer variables.

• Let the index of the current tree's root node in preorder be denoted as \(i\).
• Let the index of the current tree's root node in inorder be denoted as \(m\).
• Let the index interval of the current tree in inorder be denoted as \([l, r]\).

As shown in Table 12-1, the above variables can represent the index of the root node in preorder as well as the index intervals of the subtrees in inorder.

Table 12-1   Indexes of the root node and subtrees in preorder and inorder traversals

	Root node index in preorder	Subtree index interval in inorder
Current tree	\(i\)	\([l, r]\)
Left subtree	\(i + 1\)	\([l, m-1]\)
Right subtree	\(i + 1 + (m - l)\)	\([m+1, r]\)

Please note, the meaning of \((m-l)\) in the right subtree root index is "the number of nodes in the left subtree", which is suggested to be understood in conjunction with the diagram below.

Figure 12-7   Indexes of the root node and left and right subtrees

4.   Code implementation

To improve the efficiency of querying \(m\), we use a hash table hmap to store the mapping of elements in inorder to their indexes:

PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRubyZig

build_tree.py

def dfs(
    preorder: list[int],
    inorder_map: dict[int, int],
    i: int,
    l: int,
    r: int,
) -> TreeNode | None:
    """构建二叉树：分治"""
    # 子树区间为空时终止
    if r - l < 0:
        return None
    # 初始化根节点
    root = TreeNode(preorder[i])
    # 查询 m ，从而划分左右子树
    m = inorder_map[preorder[i]]
    # 子问题：构建左子树
    root.left = dfs(preorder, inorder_map, i + 1, l, m - 1)
    # 子问题：构建右子树
    root.right = dfs(preorder, inorder_map, i + 1 + m - l, m + 1, r)
    # 返回根节点
    return root

def build_tree(preorder: list[int], inorder: list[int]) -> TreeNode | None:
    """构建二叉树"""
    # 初始化哈希表，存储 inorder 元素到索引的映射
    inorder_map = {val: i for i, val in enumerate(inorder)}
    root = dfs(preorder, inorder_map, 0, 0, len(inorder) - 1)
    return root

build_tree.cpp

/* 构建二叉树：分治 */
TreeNode *dfs(vector<int> &preorder, unordered_map<int, int> &inorderMap, int i, int l, int r) {
    // 子树区间为空时终止
    if (r - l < 0)
        return NULL;
    // 初始化根节点
    TreeNode *root = new TreeNode(preorder[i]);
    // 查询 m ，从而划分左右子树
    int m = inorderMap[preorder[i]];
    // 子问题：构建左子树
    root->left = dfs(preorder, inorderMap, i + 1, l, m - 1);
    // 子问题：构建右子树
    root->right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);
    // 返回根节点
    return root;
}

/* 构建二叉树 */
TreeNode *buildTree(vector<int> &preorder, vector<int> &inorder) {
    // 初始化哈希表，存储 inorder 元素到索引的映射
    unordered_map<int, int> inorderMap;
    for (int i = 0; i < inorder.size(); i++) {
        inorderMap[inorder[i]] = i;
    }
    TreeNode *root = dfs(preorder, inorderMap, 0, 0, inorder.size() - 1);
    return root;
}

build_tree.java

/* 构建二叉树：分治 */
TreeNode dfs(int[] preorder, Map<Integer, Integer> inorderMap, int i, int l, int r) {
    // 子树区间为空时终止
    if (r - l < 0)
        return null;
    // 初始化根节点
    TreeNode root = new TreeNode(preorder[i]);
    // 查询 m ，从而划分左右子树
    int m = inorderMap.get(preorder[i]);
    // 子问题：构建左子树
    root.left = dfs(preorder, inorderMap, i + 1, l, m - 1);
    // 子问题：构建右子树
    root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);
    // 返回根节点
    return root;
}

/* 构建二叉树 */
TreeNode buildTree(int[] preorder, int[] inorder) {
    // 初始化哈希表，存储 inorder 元素到索引的映射
    Map<Integer, Integer> inorderMap = new HashMap<>();
    for (int i = 0; i < inorder.length; i++) {
        inorderMap.put(inorder[i], i);
    }
    TreeNode root = dfs(preorder, inorderMap, 0, 0, inorder.length - 1);
    return root;
}

build_tree.cs

/* 构建二叉树：分治 */
TreeNode? DFS(int[] preorder, Dictionary<int, int> inorderMap, int i, int l, int r) {
    // 子树区间为空时终止
    if (r - l < 0)
        return null;
    // 初始化根节点
    TreeNode root = new(preorder[i]);
    // 查询 m ，从而划分左右子树
    int m = inorderMap[preorder[i]];
    // 子问题：构建左子树
    root.left = DFS(preorder, inorderMap, i + 1, l, m - 1);
    // 子问题：构建右子树
    root.right = DFS(preorder, inorderMap, i + 1 + m - l, m + 1, r);
    // 返回根节点
    return root;
}

/* 构建二叉树 */
TreeNode? BuildTree(int[] preorder, int[] inorder) {
    // 初始化哈希表，存储 inorder 元素到索引的映射
    Dictionary<int, int> inorderMap = [];
    for (int i = 0; i < inorder.Length; i++) {
        inorderMap.TryAdd(inorder[i], i);
    }
    TreeNode? root = DFS(preorder, inorderMap, 0, 0, inorder.Length - 1);
    return root;
}

build_tree.go

/* 构建二叉树：分治 */
func dfsBuildTree(preorder []int, inorderMap map[int]int, i, l, r int) *TreeNode {
    // 子树区间为空时终止
    if r-l < 0 {
        return nil
    }
    // 初始化根节点
    root := NewTreeNode(preorder[i])
    // 查询 m ，从而划分左右子树
    m := inorderMap[preorder[i]]
    // 子问题：构建左子树
    root.Left = dfsBuildTree(preorder, inorderMap, i+1, l, m-1)
    // 子问题：构建右子树
    root.Right = dfsBuildTree(preorder, inorderMap, i+1+m-l, m+1, r)
    // 返回根节点
    return root
}

/* 构建二叉树 */
func buildTree(preorder, inorder []int) *TreeNode {
    // 初始化哈希表，存储 inorder 元素到索引的映射
    inorderMap := make(map[int]int, len(inorder))
    for i := 0; i < len(inorder); i++ {
        inorderMap[inorder[i]] = i
    }

    root := dfsBuildTree(preorder, inorderMap, 0, 0, len(inorder)-1)
    return root
}

build_tree.swift

/* 构建二叉树：分治 */
func dfs(preorder: [Int], inorderMap: [Int: Int], i: Int, l: Int, r: Int) -> TreeNode? {
    // 子树区间为空时终止
    if r - l < 0 {
        return nil
    }
    // 初始化根节点
    let root = TreeNode(x: preorder[i])
    // 查询 m ，从而划分左右子树
    let m = inorderMap[preorder[i]]!
    // 子问题：构建左子树
    root.left = dfs(preorder: preorder, inorderMap: inorderMap, i: i + 1, l: l, r: m - 1)
    // 子问题：构建右子树
    root.right = dfs(preorder: preorder, inorderMap: inorderMap, i: i + 1 + m - l, l: m + 1, r: r)
    // 返回根节点
    return root
}

/* 构建二叉树 */
func buildTree(preorder: [Int], inorder: [Int]) -> TreeNode? {
    // 初始化哈希表，存储 inorder 元素到索引的映射
    let inorderMap = inorder.enumerated().reduce(into: [:]) { $0[$1.element] = $1.offset }
    return dfs(preorder: preorder, inorderMap: inorderMap, i: inorder.startIndex, l: inorder.startIndex, r: inorder.endIndex - 1)
}

build_tree.js

/* 构建二叉树：分治 */
function dfs(preorder, inorderMap, i, l, r) {
    // 子树区间为空时终止
    if (r - l < 0) return null;
    // 初始化根节点
    const root = new TreeNode(preorder[i]);
    // 查询 m ，从而划分左右子树
    const m = inorderMap.get(preorder[i]);
    // 子问题：构建左子树
    root.left = dfs(preorder, inorderMap, i + 1, l, m - 1);
    // 子问题：构建右子树
    root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);
    // 返回根节点
    return root;
}

/* 构建二叉树 */
function buildTree(preorder, inorder) {
    // 初始化哈希表，存储 inorder 元素到索引的映射
    let inorderMap = new Map();
    for (let i = 0; i < inorder.length; i++) {
        inorderMap.set(inorder[i], i);
    }
    const root = dfs(preorder, inorderMap, 0, 0, inorder.length - 1);
    return root;
}

build_tree.ts

/* 构建二叉树：分治 */
function dfs(
    preorder: number[],
    inorderMap: Map<number, number>,
    i: number,
    l: number,
    r: number
): TreeNode | null {
    // 子树区间为空时终止
    if (r - l < 0) return null;
    // 初始化根节点
    const root: TreeNode = new TreeNode(preorder[i]);
    // 查询 m ，从而划分左右子树
    const m = inorderMap.get(preorder[i]);
    // 子问题：构建左子树
    root.left = dfs(preorder, inorderMap, i + 1, l, m - 1);
    // 子问题：构建右子树
    root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);
    // 返回根节点
    return root;
}

/* 构建二叉树 */
function buildTree(preorder: number[], inorder: number[]): TreeNode | null {
    // 初始化哈希表，存储 inorder 元素到索引的映射
    let inorderMap = new Map<number, number>();
    for (let i = 0; i < inorder.length; i++) {
        inorderMap.set(inorder[i], i);
    }
    const root = dfs(preorder, inorderMap, 0, 0, inorder.length - 1);
    return root;
}

build_tree.dart

/* 构建二叉树：分治 */
TreeNode? dfs(
  List<int> preorder,
  Map<int, int> inorderMap,
  int i,
  int l,
  int r,
) {
  // 子树区间为空时终止
  if (r - l < 0) {
    return null;
  }
  // 初始化根节点
  TreeNode? root = TreeNode(preorder[i]);
  // 查询 m ，从而划分左右子树
  int m = inorderMap[preorder[i]]!;
  // 子问题：构建左子树
  root.left = dfs(preorder, inorderMap, i + 1, l, m - 1);
  // 子问题：构建右子树
  root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);
  // 返回根节点
  return root;
}

/* 构建二叉树 */
TreeNode? buildTree(List<int> preorder, List<int> inorder) {
  // 初始化哈希表，存储 inorder 元素到索引的映射
  Map<int, int> inorderMap = {};
  for (int i = 0; i < inorder.length; i++) {
    inorderMap[inorder[i]] = i;
  }
  TreeNode? root = dfs(preorder, inorderMap, 0, 0, inorder.length - 1);
  return root;
}

build_tree.rs

/* 构建二叉树：分治 */
fn dfs(
    preorder: &[i32],
    inorder_map: &HashMap<i32, i32>,
    i: i32,
    l: i32,
    r: i32,
) -> Option<Rc<RefCell<TreeNode>>> {
    // 子树区间为空时终止
    if r - l < 0 {
        return None;
    }
    // 初始化根节点
    let root = TreeNode::new(preorder[i as usize]);
    // 查询 m ，从而划分左右子树
    let m = inorder_map.get(&preorder[i as usize]).unwrap();
    // 子问题：构建左子树
    root.borrow_mut().left = dfs(preorder, inorder_map, i + 1, l, m - 1);
    // 子问题：构建右子树
    root.borrow_mut().right = dfs(preorder, inorder_map, i + 1 + m - l, m + 1, r);
    // 返回根节点
    Some(root)
}

/* 构建二叉树 */
fn build_tree(preorder: &[i32], inorder: &[i32]) -> Option<Rc<RefCell<TreeNode>>> {
    // 初始化哈希表，存储 inorder 元素到索引的映射
    let mut inorder_map: HashMap<i32, i32> = HashMap::new();
    for i in 0..inorder.len() {
        inorder_map.insert(inorder[i], i as i32);
    }
    let root = dfs(preorder, &inorder_map, 0, 0, inorder.len() as i32 - 1);
    root
}

build_tree.c

/* 构建二叉树：分治 */
TreeNode *dfs(int *preorder, int *inorderMap, int i, int l, int r, int size) {
    // 子树区间为空时终止
    if (r - l < 0)
        return NULL;
    // 初始化根节点
    TreeNode *root = (TreeNode *)malloc(sizeof(TreeNode));
    root->val = preorder[i];
    root->left = NULL;
    root->right = NULL;
    // 查询 m ，从而划分左右子树
    int m = inorderMap[preorder[i]];
    // 子问题：构建左子树
    root->left = dfs(preorder, inorderMap, i + 1, l, m - 1, size);
    // 子问题：构建右子树
    root->right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r, size);
    // 返回根节点
    return root;
}

/* 构建二叉树 */
TreeNode *buildTree(int *preorder, int preorderSize, int *inorder, int inorderSize) {
    // 初始化哈希表，存储 inorder 元素到索引的映射
    int *inorderMap = (int *)malloc(sizeof(int) * MAX_SIZE);
    for (int i = 0; i < inorderSize; i++) {
        inorderMap[inorder[i]] = i;
    }
    TreeNode *root = dfs(preorder, inorderMap, 0, 0, inorderSize - 1, inorderSize);
    free(inorderMap);
    return root;
}

build_tree.kt

/* 构建二叉树：分治 */
fun dfs(
    preorder: IntArray,
    inorderMap: Map<Int?, Int?>,
    i: Int,
    l: Int,
    r: Int
): TreeNode? {
    // 子树区间为空时终止
    if (r - l < 0) return null
    // 初始化根节点
    val root = TreeNode(preorder[i])
    // 查询 m ，从而划分左右子树
    val m = inorderMap[preorder[i]]!!
    // 子问题：构建左子树
    root.left = dfs(preorder, inorderMap, i + 1, l, m - 1)
    // 子问题：构建右子树
    root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r)
    // 返回根节点
    return root
}

/* 构建二叉树 */
fun buildTree(preorder: IntArray, inorder: IntArray): TreeNode? {
    // 初始化哈希表，存储 inorder 元素到索引的映射
    val inorderMap = HashMap<Int?, Int?>()
    for (i in inorder.indices) {
        inorderMap[inorder[i]] = i
    }
    val root = dfs(preorder, inorderMap, 0, 0, inorder.size - 1)
    return root
}

build_tree.rb

[class]{}-[func]{dfs}

[class]{}-[func]{build_tree}

build_tree.zig

[class]{}-[func]{dfs}

[class]{}-[func]{buildTree}

Code Visualization

Full Screen >

The diagram below shows the recursive process of building the binary tree, where each node is established during the "descending" process, and each edge (reference) is established during the "ascending" process.

<1><2><3><4><5><6><7><8><9>

Figure 12-8   Recursive process of building a binary tree

Each recursive function's division results of preorder and inorder are shown in the diagram below.

Figure 12-9   Division results in each recursive function

Assuming the number of nodes in the tree is \(n\), initializing each node (executing a recursive function dfs()) takes \(O(1)\) time. Thus, the overall time complexity is \(O(n)\).

The hash table stores the mapping of inorder elements to their indexes, with a space complexity of \(O(n)\). In the worst case, when the binary tree degenerates into a linked list, the recursive depth reaches \(n\), using \(O(n)\) stack frame space. Therefore, the overall space complexity is \(O(n)\).

Feel free to drop your insights, questions or suggestions