build

chapter_tree/array_representation_of_tree.md

@@ -62,7 +62,7 @@ comments: true
     tree := []any{1, 2, 3, 4, nil, 6, 7, 8, 9, nil, nil, 12, nil, nil, 15}
     ```
 
-=== "JavaScript"
+=== "JS"
 
     ```javascript title=""
     /* 二叉树的数组表示 */
@@ -70,7 +70,7 @@ comments: true
     let tree = [1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15];
     ```
 
-=== "TypeScript"
+=== "TS"
 
     ```typescript title=""
     /* 二叉树的数组表示 */
@@ -403,16 +403,110 @@ comments: true
 === "Go"
 
     ```go title="array_binary_tree.go"
-    [class]{arrayBinaryTree}-[func]{}
+    /* 数组表示下的二叉树类 */
+    type arrayBinaryTree struct {
+        tree []any
+    }
+
+    /* 构造方法 */
+    func newArrayBinaryTree(arr []any) *arrayBinaryTree {
+        return &arrayBinaryTree{
+            tree: arr,
+        }
+    }
+
+    /* 节点数量 */
+    func (abt *arrayBinaryTree) size() int {
+        return len(abt.tree)
+    }
+
+    /* 获取索引为 i 节点的值 */
+    func (abt *arrayBinaryTree) val(i int) any {
+        // 若索引越界，则返回 null ，代表空位
+        if i < 0 || i >= abt.size() {
+            return nil
+        }
+        return abt.tree[i]
+    }
+
+    /* 获取索引为 i 节点的左子节点的索引 */
+    func (abt *arrayBinaryTree) left(i int) int {
+        return 2*i + 1
+    }
+
+    /* 获取索引为 i 节点的右子节点的索引 */
+    func (abt *arrayBinaryTree) right(i int) int {
+        return 2*i + 2
+    }
+
+    /* 获取索引为 i 节点的父节点的索引 */
+    func (abt *arrayBinaryTree) parent(i int) int {
+        return (i - 1) / 2
+    }
+
+    /* 层序遍历 */
+    func (abt *arrayBinaryTree) levelOrder() []any {
+        var res []any
+        // 直接遍历数组
+        for i := 0; i < abt.size(); i++ {
+            if abt.val(i) != nil {
+                res = append(res, abt.val(i))
+            }
+        }
+        return res
+    }
+
+    /* 深度优先遍历 */
+    func (abt *arrayBinaryTree) dfs(i int, order string, res *[]any) {
+        // 若为空位，则返回
+        if abt.val(i) == nil {
+            return
+        }
+        // 前序遍历
+        if order == "pre" {
+            *res = append(*res, abt.val(i))
+        }
+        abt.dfs(abt.left(i), order, res)
+        // 中序遍历
+        if order == "in" {
+            *res = append(*res, abt.val(i))
+        }
+        abt.dfs(abt.right(i), order, res)
+        // 后序遍历
+        if order == "post" {
+            *res = append(*res, abt.val(i))
+        }
+    }
+
+    /* 前序遍历 */
+    func (abt *arrayBinaryTree) preOrder() []any {
+        var res []any
+        abt.dfs(0, "pre", &res)
+        return res
+    }
+
+    /* 中序遍历 */
+    func (abt *arrayBinaryTree) inOrder() []any {
+        var res []any
+        abt.dfs(0, "in", &res)
+        return res
+    }
+
+    /* 后序遍历 */
+    func (abt *arrayBinaryTree) postOrder() []any {
+        var res []any
+        abt.dfs(0, "post", &res)
+        return res
+    }
     ```
 
-=== "JavaScript"
+=== "JS"
 
     ```javascript title="array_binary_tree.js"
     [class]{ArrayBinaryTree}-[func]{}
     ```
 
-=== "TypeScript"
+=== "TS"
 
     ```typescript title="array_binary_tree.ts"
     [class]{ArrayBinaryTree}-[func]{}