build

chapter_divide_and_conquer/build_binary_tree_problem.md

@@ -171,9 +171,35 @@ status: new
 === "Go"
 
     ```go title="build_tree.go"
-    [class]{}-[func]{dfs}
+    /* 构建二叉树：分治 */
+    func dfsBuildTree(preorder, inorder []int, hmap map[int]int, i, l, r int) *TreeNode {
+        // 子树区间为空时终止
+        if r-l < 0 {
+            return nil
+        }
+        // 初始化根节点
+        root := NewTreeNode(preorder[i])
+        // 查询 m ，从而划分左右子树
+        m := hmap[preorder[i]]
+        // 子问题：构建左子树
+        root.Left = dfsBuildTree(preorder, inorder, hmap, i+1, l, m-1)
+        // 子问题：构建右子树
+        root.Right = dfsBuildTree(preorder, inorder, hmap, i+1+m-l, m+1, r)
+        // 返回根节点
+        return root
+    }
 
-    [class]{}-[func]{buildTree}
+    /* 构建二叉树 */
+    func buildTree(preorder, inorder []int) *TreeNode {
+        // 初始化哈希表，存储 inorder 元素到索引的映射
+        hmap := make(map[int]int, len(inorder))
+        for i := 0; i < len(inorder); i++ {
+            hmap[inorder[i]] = i
+        }
+
+        root := dfsBuildTree(preorder, inorder, hmap, 0, 0, len(inorder)-1)
+        return root
+    }
     ```
 
 === "JavaScript"

chapter_divide_and_conquer/hanota_problem.md

@@ -193,11 +193,37 @@ status: new
 === "Go"
 
     ```go title="hanota.go"
-    [class]{}-[func]{move}
+    /* 移动一个圆盘 */
+    func move(src, tar *list.List) {
+        // 从 src 顶部拿出一个圆盘
+        pan := src.Back()
+        // 将圆盘放入 tar 顶部
+        tar.PushBack(pan.Value)
+        // 移除 src 顶部圆盘
+        src.Remove(pan)
+    }
 
-    [class]{}-[func]{dfs}
+    /* 求解汉诺塔：问题 f(i) */
+    func dfsHanota(i int, src, buf, tar *list.List) {
+        // 若 src 只剩下一个圆盘，则直接将其移到 tar
+        if i == 1 {
+            move(src, tar)
+            return
+        }
+        // 子问题 f(i-1) ：将 src 顶部 i-1 个圆盘借助 tar 移到 buf
+        dfsHanota(i-1, src, tar, buf)
+        // 子问题 f(1) ：将 src 剩余一个圆盘移到 tar
+        move(src, tar)
+        // 子问题 f(i-1) ：将 buf 顶部 i-1 个圆盘借助 src 移到 tar
+        dfsHanota(i-1, buf, src, tar)
+    }
 
-    [class]{}-[func]{hanota}
+    /* 求解汉诺塔 */
+    func hanota(A, B, C *list.List) {
+        n := A.Len()
+        // 将 A 顶部 n 个圆盘借助 B 移到 C
+        dfsHanota(n, A, B, C)
+    }
     ```
 
 === "JavaScript"