コンテンツにスキップ
日本語版のレビュアーを募集しています。詳しくは こちら をご覧ください。

# 12.3 二分木の構築問題

Question

二分木の前順走査 `preorder` と中順走査 `inorder` が与えられたとき、これらから二分木を構築し、その根ノードを返してください。二分木には値が重複するノードが存在しないものとします（下図のとおり）。

図 12-5 二分木を構築する例のデータ

### 1. 分割統治問題かどうかを判断する

元の問題は `preorder` と `inorder` から二分木を構築することであり、典型的な分割統治問題です。

- 問題は分解できる：分割統治の観点から見ると、元の問題は 2 つの部分問題、すなわち左部分木の構築と右部分木の構築に分けられ、さらに根ノードを初期化する 1 ステップが加わります。各部分木（部分問題）に対しても、同じ分割方法を再利用してより小さな部分木（部分問題）へと分けていき、最小の部分問題（空部分木）に達した時点で終了します。
- 部分問題は独立している：左部分木と右部分木は互いに独立しており、両者の間に重なりはありません。左部分木を構築するときは、中順走査と前順走査のうち左部分木に対応する部分だけを見れば十分です。右部分木も同様です。
- 部分問題の解は統合できる：左部分木と右部分木（部分問題の解）が得られたら、それらを根ノードに接続することで元の問題の解を得られます。

### 2. 部分木をどのように分割するか

以上の分析より、この問題は分割統治で解けます。では、前順走査 `preorder` と中順走査 `inorder` を使って左部分木と右部分木をどのように分割すればよいのでしょうか？

定義に従うと、`preorder` と `inorder` はいずれも 3 つの部分に分けられます。

- 前順走査：`[ 根ノード | 左部分木 | 右部分木 ]` ，例えば上図の木は `[ 3 | 9 | 2 1 7 ]` に対応します。
- 中順走査：`[ 左部分木 | 根ノード | 右部分木 ]` ，例えば上図の木は `[ 9 | 3 | 1 2 7 ]` に対応します。

上図のデータを例にすると、下図の手順によって分割結果を得られます。

1. 前順走査の先頭要素 3 が根ノードの値です。
2. 根ノード 3 の `inorder` におけるインデックスを探すと、そのインデックスを用いて `inorder` を `[ 9 | 3 | 1 2 7 ]` に分割できます。
3. `inorder` の分割結果から、左部分木と右部分木のノード数はそれぞれ 1 と 3 であることがわかり、したがって `preorder` を `[ 3 | 9 | 2 1 7 ]` に分割できます。

図 12-6 前順走査と中順走査で部分木を分割する

### 3. 変数を用いて部分木区間を記述する

以上の分割方法により、**根ノード、左部分木、右部分木が `preorder` と `inorder` の中で占めるインデックス区間**が得られました。これらのインデックス区間を表すために、いくつかのポインタ変数を導入します。

- 現在の木の根ノードが `preorder` に現れるインデックスを \(i\) とします。
- 現在の木の根ノードが `inorder` に現れるインデックスを \(m\) とします。
- 現在の木が `inorder` において占めるインデックス区間を \([l, r]\) とします。

次の表のように、これらの変数を用いれば根ノードの `preorder` におけるインデックスと、部分木の `inorder` におけるインデックス区間を表せます。

表 12-1 根ノードと部分木の前順走査・中順走査におけるインデックス

| 根ノードの `preorder` におけるインデックス | 部分木の `inorder` におけるインデックス区間
--- | --- | ---
現在の木 | \(i\) | \([l, r]\)
左部分木 | \(i + 1\) | \([l, m-1]\)
右部分木 | \(i + 1 + (m - l)\) | \([m+1, r]\)

右部分木の根ノードのインデックスにある \((m-l)\) は「左部分木のノード数」を意味します。下図と合わせて理解することを勧めます。

図 12-7 根ノードと左右部分木のインデックス区間の表し方

### 4. コードの実装

\(m\) の検索効率を高めるために、ハッシュテーブル `hmap` を用いて配列 `inorder` の要素からインデックスへの対応を保存します。

Python C++Java C#Go Swift JS TS Dart Rust C Kotlin Ruby
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

    ### 二分木を構築：分割統治 ###
    def dfs(preorder, inorder_map, i, l, r)
      # 部分木区間が空なら終了する
      return if r - l < 0

      # ルートノードを初期化する
      root = TreeNode.new(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)

      # 根ノードを返す
      root
    end

    ### 二分木を構築 ###
    def build_tree(preorder, inorder)
      # inorder の要素からインデックスへの対応を格納するハッシュテーブルを初期化する
      inorder_map = {}
      inorder.each_with_index { |val, i| inorder_map[val] = i }
      dfs(preorder, inorder_map, 0, 0, inorder.length - 1)
    end

コードの可視化

全画面で見る >

下図は二分木を構築する再帰過程を示しています。各ノードは下向きに「再帰していく」過程で生成され、各辺（参照）は上向きに「戻る」過程で張られます。

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

図 12-8 二分木を構築する再帰過程

各再帰関数における前順走査 `preorder` と中順走査 `inorder` の分割結果を下図に示します。

図 12-9 各再帰関数での分割結果

木のノード数を \(n\) とすると、各ノードの初期化（再帰関数 `dfs()` の 1 回の実行）には \(O(1)\) 時間かかります。したがって、全体の時間計算量は \(O(n)\) です。

ハッシュテーブルには `inorder` の要素からインデックスへの対応を保存するため、空間計算量は \(O(n)\) です。最悪の場合、すなわち二分木が連結リストに退化すると、再帰の深さは \(n\) に達し、\(O(n)\) のスタックフレーム空間を使用します。したがって、全体の空間計算量は \(O(n)\) です。

##### ご意見、ご質問、ご提案があればぜひコメントしてください