build

2025-07-28 04:42:48 +08:00 · 2024-04-02 19:00:01 +08:00
parent bd0535ab5a
commit 20f79f5f32
19 changed files with 13343 additions and 2 deletions
--- a/en/docs/chapter_tree/array_representation_of_tree.md
+++ b/en/docs/chapter_tree/array_representation_of_tree.md
--- a/en/docs/chapter_tree/avl_tree.md
+++ b/en/docs/chapter_tree/avl_tree.md
--- a/en/docs/chapter_tree/binary_search_tree.md
+++ b/en/docs/chapter_tree/binary_search_tree.md
--- a/en/docs/chapter_tree/binary_tree.md
+++ b/en/docs/chapter_tree/binary_tree.md
@ -0,0 +1,686 @@
+---
+comments: true
+---
+
+# 7.1 &nbsp; Binary tree
+
+A "binary tree" is a non-linear data structure that represents the ancestral and descendent relationships, embodying the "divide and conquer" logic. Similar to a linked list, the basic unit of a binary tree is a node, each containing a value, a reference to the left child node, and a reference to the right child node.
+
+=== "Python"
+
+    ```python title=""
+    class TreeNode:
+        """Binary tree node"""
+        def __init__(self, val: int):
+            self.val: int = val                # Node value
+            self.left: TreeNode | None = None  # Reference to left child node
+            self.right: TreeNode | None = None # Reference to right child node
+    ```
+
+=== "C++"
+
+    ```cpp title=""
+    /* Binary tree node */
+    struct TreeNode {
+        int val;          // Node value
+        TreeNode *left;   // Pointer to left child node
+        TreeNode *right;  // Pointer to right child node
+        TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+    };
+    ```
+
+=== "Java"
+
+    ```java title=""
+    /* Binary tree node */
+    class TreeNode {
+        int val;         // Node value
+        TreeNode left;   // Reference to left child node
+        TreeNode right;  // Reference to right child node
+        TreeNode(int x) { val = x; }
+    }
+    ```
+
+=== "C#"
+
+    ```csharp title=""
+    /* Binary tree node */
+    class TreeNode(int? x) {
+        public int? val = x;    // Node value
+        public TreeNode? left;  // Reference to left child node
+        public TreeNode? right; // Reference to right child node
+    }
+    ```
+
+=== "Go"
+
+    ```go title=""
+    /* Binary tree node */
+    type TreeNode struct {
+        Val   int
+        Left  *TreeNode
+        Right *TreeNode
+    }
+    /* 构造方法 */
+    func NewTreeNode(v int) *TreeNode {
+        return &TreeNode{
+            Left:  nil, // Pointer to left child node
+            Right: nil, // Pointer to right child node
+            Val:   v,   // Node value
+        }
+    }
+    ```
+
+=== "Swift"
+
+    ```swift title=""
+    /* Binary tree node */
+    class TreeNode {
+        var val: Int // Node value
+        var left: TreeNode? // Reference to left child node
+        var right: TreeNode? // Reference to right child node
+
+        init(x: Int) {
+            val = x
+        }
+    }
+    ```
+
+=== "JS"
+
+    ```javascript title=""
+    /* Binary tree node */
+    class TreeNode {
+        val; // Node value
+        left; // Pointer to left child node
+        right; // Pointer to right child node
+        constructor(val, left, right) {
+            this.val = val === undefined ? 0 : val;
+            this.left = left === undefined ? null : left;
+            this.right = right === undefined ? null : right;
+        }
+    }
+    ```
+
+=== "TS"
+
+    ```typescript title=""
+    /* Binary tree node */
+    class TreeNode {
+        val: number;
+        left: TreeNode | null;
+        right: TreeNode | null;
+    
+        constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
+            this.val = val === undefined ? 0 : val; // Node value
+            this.left = left === undefined ? null : left; // Reference to left child node
+            this.right = right === undefined ? null : right; // Reference to right child node
+        }
+    }
+    ```
+
+=== "Dart"
+
+    ```dart title=""
+    /* Binary tree node */
+    class TreeNode {
+      int val;         // Node value
+      TreeNode? left;  // Reference to left child node
+      TreeNode? right; // Reference to right child node
+      TreeNode(this.val, [this.left, this.right]);
+    }
+    ```
+
+=== "Rust"
+
+    ```rust title=""
+    use std::rc::Rc;
+    use std::cell::RefCell;
+
+    /* Binary tree node */
+    struct TreeNode {
+        val: i32,                               // Node value
+        left: Option<Rc<RefCell<TreeNode>>>,    // Reference to left child node
+        right: Option<Rc<RefCell<TreeNode>>>,   // Reference to right child node
+    }
+
+    impl TreeNode {
+        /* 构造方法 */
+        fn new(val: i32) -> Rc<RefCell<Self>> {
+            Rc::new(RefCell::new(Self {
+                val,
+                left: None,
+                right: None
+            }))
+        }
+    }
+    ```
+
+=== "C"
+
+    ```c title=""
+    /* Binary tree node */
+    typedef struct TreeNode {
+        int val;                // Node value
+        int height;             // 节点高度
+        struct TreeNode *left;  // Pointer to left child node
+        struct TreeNode *right; // Pointer to right child node
+    } TreeNode;
+
+    /* 构造函数 */
+    TreeNode *newTreeNode(int val) {
+        TreeNode *node;
+
+        node = (TreeNode *)malloc(sizeof(TreeNode));
+        node->val = val;
+        node->height = 0;
+        node->left = NULL;
+        node->right = NULL;
+        return node;
+    }
+    ```
+
+=== "Kotlin"
+
+    ```kotlin title=""
+    /* Binary tree node */
+    class TreeNode(val _val: Int) {  // Node value
+        val left: TreeNode? = null   // Reference to left child node
+        val right: TreeNode? = null  // Reference to right child node
+    }
+    ```
+
+=== "Ruby"
+
+    ```ruby title=""
+
+    ```
+
+=== "Zig"
+
+    ```zig title=""
+
+    ```
+
+Each node has two references (pointers), pointing to the "left-child node" and "right-child node," respectively. This node is called the "parent node" of these two child nodes. When given a node of a binary tree, we call the tree formed by this node's left child and all nodes under it the "left subtree" of this node. Similarly, the "right subtree" can be defined.
+
+**In a binary tree, except for leaf nodes, all other nodes contain child nodes and non-empty subtrees.** As shown in the Figure 7-1 , if "Node 2" is considered as the parent node, then its left and right child nodes are "Node 4" and "Node 5," respectively. The left subtree is "the tree formed by Node 4 and all nodes under it," and the right subtree is "the tree formed by Node 5 and all nodes under it."
+
+![Parent Node, child Node, subtree](binary_tree.assets/binary_tree_definition.png){ class="animation-figure" }
+
+<p align="center"> Figure 7-1 &nbsp; Parent Node, child Node, subtree </p>
+
+## 7.1.1 &nbsp; Common terminology of binary trees
+
+The commonly used terminology of binary trees is shown in the following figure.
+
+- "Root node": The node at the top level of the binary tree, which has no parent node.
+- "Leaf node": A node with no children, both of its pointers point to `None`.
+- "Edge": The line segment connecting two nodes, i.e., node reference (pointer).
+- The "level" of a node: Incrementing from top to bottom, with the root node's level being 1.
+- The "degree" of a node: The number of a node's children. In a binary tree, the degree can be 0, 1, or 2.
+- The "height" of a binary tree: The number of edges passed from the root node to the farthest leaf node.
+- The "depth" of a node: The number of edges passed from the root node to the node.
+- The "height" of a node: The number of edges from the farthest leaf node to the node.
+
+![Common Terminology of Binary Trees](binary_tree.assets/binary_tree_terminology.png){ class="animation-figure" }
+
+<p align="center"> Figure 7-2 &nbsp; Common Terminology of Binary Trees </p>
+
+!!! tip
+
+    Please note that we usually define "height" and "depth" as "the number of edges passed," but some problems or textbooks may define them as "the number of nodes passed." In this case, both height and depth need to be incremented by 1.
+
+## 7.1.2 &nbsp; Basic operations of binary trees
+
+### 1. &nbsp; Initializing a binary tree
+
+Similar to a linked list, initialize nodes first, then construct references (pointers).
+
+=== "Python"
+
+    ```python title="binary_tree.py"
+    # Initializing a binary tree
+    # Initializing nodes
+    n1 = TreeNode(val=1)
+    n2 = TreeNode(val=2)
+    n3 = TreeNode(val=3)
+    n4 = TreeNode(val=4)
+    n5 = TreeNode(val=5)
+    # Linking references (pointers) between nodes
+    n1.left = n2
+    n1.right = n3
+    n2.left = n4
+    n2.right = n5
+    ```
+
+=== "C++"
+
+    ```cpp title="binary_tree.cpp"
+    /* Initializing a binary tree */
+    // Initializing nodes
+    TreeNode* n1 = new TreeNode(1);
+    TreeNode* n2 = new TreeNode(2);
+    TreeNode* n3 = new TreeNode(3);
+    TreeNode* n4 = new TreeNode(4);
+    TreeNode* n5 = new TreeNode(5);
+    // Linking references (pointers) between nodes
+    n1->left = n2;
+    n1->right = n3;
+    n2->left = n4;
+    n2->right = n5;
+    ```
+
+=== "Java"
+
+    ```java title="binary_tree.java"
+    // Initializing nodes
+    TreeNode n1 = new TreeNode(1);
+    TreeNode n2 = new TreeNode(2);
+    TreeNode n3 = new TreeNode(3);
+    TreeNode n4 = new TreeNode(4);
+    TreeNode n5 = new TreeNode(5);
+    // Linking references (pointers) between nodes
+    n1.left = n2;
+    n1.right = n3;
+    n2.left = n4;
+    n2.right = n5;
+    ```
+
+=== "C#"
+
+    ```csharp title="binary_tree.cs"
+    /* Initializing a binary tree */
+    // Initializing nodes
+    TreeNode n1 = new(1);
+    TreeNode n2 = new(2);
+    TreeNode n3 = new(3);
+    TreeNode n4 = new(4);
+    TreeNode n5 = new(5);
+    // Linking references (pointers) between nodes
+    n1.left = n2;
+    n1.right = n3;
+    n2.left = n4;
+    n2.right = n5;
+    ```
+
+=== "Go"
+
+    ```go title="binary_tree.go"
+    /* Initializing a binary tree */
+    // Initializing nodes
+    n1 := NewTreeNode(1)
+    n2 := NewTreeNode(2)
+    n3 := NewTreeNode(3)
+    n4 := NewTreeNode(4)
+    n5 := NewTreeNode(5)
+    // Linking references (pointers) between nodes
+    n1.Left = n2
+    n1.Right = n3
+    n2.Left = n4
+    n2.Right = n5
+    ```
+
+=== "Swift"
+
+    ```swift title="binary_tree.swift"
+    // Initializing nodes
+    let n1 = TreeNode(x: 1)
+    let n2 = TreeNode(x: 2)
+    let n3 = TreeNode(x: 3)
+    let n4 = TreeNode(x: 4)
+    let n5 = TreeNode(x: 5)
+    // Linking references (pointers) between nodes
+    n1.left = n2
+    n1.right = n3
+    n2.left = n4
+    n2.right = n5
+    ```
+
+=== "JS"
+
+    ```javascript title="binary_tree.js"
+    /* Initializing a binary tree */
+    // Initializing nodes
+    let n1 = new TreeNode(1),
+        n2 = new TreeNode(2),
+        n3 = new TreeNode(3),
+        n4 = new TreeNode(4),
+        n5 = new TreeNode(5);
+    // Linking references (pointers) between nodes
+    n1.left = n2;
+    n1.right = n3;
+    n2.left = n4;
+    n2.right = n5;
+    ```
+
+=== "TS"
+
+    ```typescript title="binary_tree.ts"
+    /* Initializing a binary tree */
+    // Initializing nodes
+    let n1 = new TreeNode(1),
+        n2 = new TreeNode(2),
+        n3 = new TreeNode(3),
+        n4 = new TreeNode(4),
+        n5 = new TreeNode(5);
+    // Linking references (pointers) between nodes
+    n1.left = n2;
+    n1.right = n3;
+    n2.left = n4;
+    n2.right = n5;
+    ```
+
+=== "Dart"
+
+    ```dart title="binary_tree.dart"
+    /* Initializing a binary tree */
+    // Initializing nodes
+    TreeNode n1 = new TreeNode(1);
+    TreeNode n2 = new TreeNode(2);
+    TreeNode n3 = new TreeNode(3);
+    TreeNode n4 = new TreeNode(4);
+    TreeNode n5 = new TreeNode(5);
+    // Linking references (pointers) between nodes
+    n1.left = n2;
+    n1.right = n3;
+    n2.left = n4;
+    n2.right = n5;
+    ```
+
+=== "Rust"
+
+    ```rust title="binary_tree.rs"
+    // Initializing nodes
+    let n1 = TreeNode::new(1);
+    let n2 = TreeNode::new(2);
+    let n3 = TreeNode::new(3);
+    let n4 = TreeNode::new(4);
+    let n5 = TreeNode::new(5);
+    // Linking references (pointers) between nodes
+    n1.borrow_mut().left = Some(n2.clone());
+    n1.borrow_mut().right = Some(n3);
+    n2.borrow_mut().left = Some(n4);
+    n2.borrow_mut().right = Some(n5);
+    ```
+
+=== "C"
+
+    ```c title="binary_tree.c"
+    /* Initializing a binary tree */
+    // Initializing nodes
+    TreeNode *n1 = newTreeNode(1);
+    TreeNode *n2 = newTreeNode(2);
+    TreeNode *n3 = newTreeNode(3);
+    TreeNode *n4 = newTreeNode(4);
+    TreeNode *n5 = newTreeNode(5);
+    // Linking references (pointers) between nodes
+    n1->left = n2;
+    n1->right = n3;
+    n2->left = n4;
+    n2->right = n5;
+    ```
+
+=== "Kotlin"
+
+    ```kotlin title="binary_tree.kt"
+    // Initializing nodes
+    val n1 = TreeNode(1)
+    val n2 = TreeNode(2)
+    val n3 = TreeNode(3)
+    val n4 = TreeNode(4)
+    val n5 = TreeNode(5)
+    // Linking references (pointers) between nodes
+    n1.left = n2
+    n1.right = n3
+    n2.left = n4
+    n2.right = n5
+    ```
+
+=== "Ruby"
+
+    ```ruby title="binary_tree.rb"
+
+    ```
+
+=== "Zig"
+
+    ```zig title="binary_tree.zig"
+
+    ```
+
+??? pythontutor "Code visualization"
+
+    https://pythontutor.com/render.html#code=class%20TreeNode%3A%0A%20%20%20%20%22%22%22%E4%BA%8C%E5%8F%89%E6%A0%91%E8%8A%82%E7%82%B9%E7%B1%BB%22%22%22%0A%20%20%20%20def%20__init__%28self,%20val%3A%20int%29%3A%0A%20%20%20%20%20%20%20%20self.val%3A%20int%20%3D%20val%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%23%20%E8%8A%82%E7%82%B9%E5%80%BC%0A%20%20%20%20%20%20%20%20self.left%3A%20TreeNode%20%7C%20None%20%3D%20None%20%20%23%20%E5%B7%A6%E5%AD%90%E8%8A%82%E7%82%B9%E5%BC%95%E7%94%A8%0A%20%20%20%20%20%20%20%20self.right%3A%20TreeNode%20%7C%20None%20%3D%20None%20%23%20%E5%8F%B3%E5%AD%90%E8%8A%82%E7%82%B9%E5%BC%95%E7%94%A8%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E4%BA%8C%E5%8F%89%E6%A0%91%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E8%8A%82%E7%82%B9%0A%20%20%20%20n1%20%3D%20TreeNode%28val%3D1%29%0A%20%20%20%20n2%20%3D%20TreeNode%28val%3D2%29%0A%20%20%20%20n3%20%3D%20TreeNode%28val%3D3%29%0A%20%20%20%20n4%20%3D%20TreeNode%28val%3D4%29%0A%20%20%20%20n5%20%3D%20TreeNode%28val%3D5%29%0A%20%20%20%20%23%20%E6%9E%84%E5%BB%BA%E8%8A%82%E7%82%B9%E4%B9%8B%E9%97%B4%E7%9A%84%E5%BC%95%E7%94%A8%EF%BC%88%E6%8C%87%E9%92%88%EF%BC%89%0A%20%20%20%20n1.left%20%3D%20n2%0A%20%20%20%20n1.right%20%3D%20n3%0A%20%20%20%20n2.left%20%3D%20n4%0A%20%20%20%20n2.right%20%3D%20n5&cumulative=false&curInstr=3&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=311&rawInputLstJSON=%5B%5D&textReferences=false
+
+### 2. &nbsp; Inserting and removing nodes
+
+Similar to a linked list, inserting and removing nodes in a binary tree can be achieved by modifying pointers. The Figure 7-3  provides an example.
+
+![Inserting and removing nodes in a binary tree](binary_tree.assets/binary_tree_add_remove.png){ class="animation-figure" }
+
+<p align="center"> Figure 7-3 &nbsp; Inserting and removing nodes in a binary tree </p>
+
+=== "Python"
+
+    ```python title="binary_tree.py"
+    # Inserting and removing nodes
+    p = TreeNode(0)
+    # Inserting node P between n1 -> n2
+    n1.left = p
+    p.left = n2
+    # Removing node P
+    n1.left = n2
+    ```
+
+=== "C++"
+
+    ```cpp title="binary_tree.cpp"
+    /* Inserting and removing nodes */
+    TreeNode* P = new TreeNode(0);
+    // Inserting node P between n1 and n2
+    n1->left = P;
+    P->left = n2;
+    // Removing node P
+    n1->left = n2;
+    ```
+
+=== "Java"
+
+    ```java title="binary_tree.java"
+    TreeNode P = new TreeNode(0);
+    // Inserting node P between n1 and n2
+    n1.left = P;
+    P.left = n2;
+    // Removing node P
+    n1.left = n2;
+    ```
+
+=== "C#"
+
+    ```csharp title="binary_tree.cs"
+    /* Inserting and removing nodes */
+    TreeNode P = new(0);
+    // Inserting node P between n1 and n2
+    n1.left = P;
+    P.left = n2;
+    // Removing node P
+    n1.left = n2;
+    ```
+
+=== "Go"
+
+    ```go title="binary_tree.go"
+    /* Inserting and removing nodes */
+    // Inserting node P between n1 and n2
+    p := NewTreeNode(0)
+    n1.Left = p
+    p.Left = n2
+    // Removing node P
+    n1.Left = n2
+    ```
+
+=== "Swift"
+
+    ```swift title="binary_tree.swift"
+    let P = TreeNode(x: 0)
+    // Inserting node P between n1 and n2
+    n1.left = P
+    P.left = n2
+    // Removing node P
+    n1.left = n2
+    ```
+
+=== "JS"
+
+    ```javascript title="binary_tree.js"
+    /* Inserting and removing nodes */
+    let P = new TreeNode(0);
+    // Inserting node P between n1 and n2
+    n1.left = P;
+    P.left = n2;
+    // Removing node P
+    n1.left = n2;
+    ```
+
+=== "TS"
+
+    ```typescript title="binary_tree.ts"
+    /* Inserting and removing nodes */
+    const P = new TreeNode(0);
+    // Inserting node P between n1 and n2
+    n1.left = P;
+    P.left = n2;
+    // Removing node P
+    n1.left = n2;
+    ```
+
+=== "Dart"
+
+    ```dart title="binary_tree.dart"
+    /* Inserting and removing nodes */
+    TreeNode P = new TreeNode(0);
+    // Inserting node P between n1 and n2
+    n1.left = P;
+    P.left = n2;
+    // Removing node P
+    n1.left = n2;
+    ```
+
+=== "Rust"
+
+    ```rust title="binary_tree.rs"
+    let p = TreeNode::new(0);
+    // Inserting node P between n1 and n2
+    n1.borrow_mut().left = Some(p.clone());
+    p.borrow_mut().left = Some(n2.clone());
+    // Removing node P
+    n1.borrow_mut().left = Some(n2);
+    ```
+
+=== "C"
+
+    ```c title="binary_tree.c"
+    /* Inserting and removing nodes */
+    TreeNode *P = newTreeNode(0);
+    // Inserting node P between n1 and n2
+    n1->left = P;
+    P->left = n2;
+    // Removing node P
+    n1->left = n2;
+    ```
+
+=== "Kotlin"
+
+    ```kotlin title="binary_tree.kt"
+    val P = TreeNode(0)
+    // Inserting node P between n1 and n2
+    n1.left = P
+    P.left = n2
+    // Removing node P
+    n1.left = n2
+    ```
+
+=== "Ruby"
+
+    ```ruby title="binary_tree.rb"
+
+    ```
+
+=== "Zig"
+
+    ```zig title="binary_tree.zig"
+
+    ```
+
+??? pythontutor "Code visualization"
+
+    https://pythontutor.com/render.html#code=class%20TreeNode%3A%0A%20%20%20%20%22%22%22%E4%BA%8C%E5%8F%89%E6%A0%91%E8%8A%82%E7%82%B9%E7%B1%BB%22%22%22%0A%20%20%20%20def%20__init__%28self,%20val%3A%20int%29%3A%0A%20%20%20%20%20%20%20%20self.val%3A%20int%20%3D%20val%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%23%20%E8%8A%82%E7%82%B9%E5%80%BC%0A%20%20%20%20%20%20%20%20self.left%3A%20TreeNode%20%7C%20None%20%3D%20None%20%20%23%20%E5%B7%A6%E5%AD%90%E8%8A%82%E7%82%B9%E5%BC%95%E7%94%A8%0A%20%20%20%20%20%20%20%20self.right%3A%20TreeNode%20%7C%20None%20%3D%20None%20%23%20%E5%8F%B3%E5%AD%90%E8%8A%82%E7%82%B9%E5%BC%95%E7%94%A8%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E4%BA%8C%E5%8F%89%E6%A0%91%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E8%8A%82%E7%82%B9%0A%20%20%20%20n1%20%3D%20TreeNode%28val%3D1%29%0A%20%20%20%20n2%20%3D%20TreeNode%28val%3D2%29%0A%20%20%20%20n3%20%3D%20TreeNode%28val%3D3%29%0A%20%20%20%20n4%20%3D%20TreeNode%28val%3D4%29%0A%20%20%20%20n5%20%3D%20TreeNode%28val%3D5%29%0A%20%20%20%20%23%20%E6%9E%84%E5%BB%BA%E8%8A%82%E7%82%B9%E4%B9%8B%E9%97%B4%E7%9A%84%E5%BC%95%E7%94%A8%EF%BC%88%E6%8C%87%E9%92%88%EF%BC%89%0A%20%20%20%20n1.left%20%3D%20n2%0A%20%20%20%20n1.right%20%3D%20n3%0A%20%20%20%20n2.left%20%3D%20n4%0A%20%20%20%20n2.right%20%3D%20n5%0A%0A%20%20%20%20%23%20%E6%8F%92%E5%85%A5%E4%B8%8E%E5%88%A0%E9%99%A4%E8%8A%82%E7%82%B9%0A%20%20%20%20p%20%3D%20TreeNode%280%29%0A%20%20%20%20%23%20%E5%9C%A8%20n1%20-%3E%20n2%20%E4%B8%AD%E9%97%B4%E6%8F%92%E5%85%A5%E8%8A%82%E7%82%B9%20P%0A%20%20%20%20n1.left%20%3D%20p%0A%20%20%20%20p.left%20%3D%20n2%0A%20%20%20%20%23%20%E5%88%A0%E9%99%A4%E8%8A%82%E7%82%B9%20P%0A%20%20%20%20n1.left%20%3D%20n2&cumulative=false&curInstr=37&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=311&rawInputLstJSON=%5B%5D&textReferences=false
+
+!!! note
+
+    It's important to note that inserting nodes may change the original logical structure of the binary tree, while removing nodes usually means removing the node and all its subtrees. Therefore, in a binary tree, insertion and removal are usually performed through a set of operations to achieve meaningful actions.
+
+## 7.1.3 &nbsp; Common types of binary trees
+
+### 1. &nbsp; Perfect binary tree
+
+As shown in the Figure 7-4 , in a "perfect binary tree," all levels of nodes are fully filled. In a perfect binary tree, the degree of leaf nodes is $0$, and the degree of all other nodes is $2$; if the tree's height is $h$, then the total number of nodes is $2^{h+1} - 1$, showing a standard exponential relationship, reflecting the common phenomenon of cell division in nature.
+
+!!! tip
+
+    Please note that in the Chinese community, a perfect binary tree is often referred to as a "full binary tree."
+
+![Perfect binary tree](binary_tree.assets/perfect_binary_tree.png){ class="animation-figure" }
+
+<p align="center"> Figure 7-4 &nbsp; Perfect binary tree </p>
+
+### 2. &nbsp; Complete binary tree
+
+As shown in the Figure 7-5 , a "complete binary tree" has only the bottom level nodes not fully filled, and the bottom level nodes are filled as far left as possible.
+
+![Complete binary tree](binary_tree.assets/complete_binary_tree.png){ class="animation-figure" }
+
+<p align="center"> Figure 7-5 &nbsp; Complete binary tree </p>
+
+### 3. &nbsp; Full binary tree
+
+As shown in the Figure 7-6 , a "full binary tree" has all nodes except leaf nodes having two children.
+
+![Full binary tree](binary_tree.assets/full_binary_tree.png){ class="animation-figure" }
+
+<p align="center"> Figure 7-6 &nbsp; Full binary tree </p>
+
+### 4. &nbsp; Balanced binary tree
+
+As shown in the Figure 7-7 , in a "balanced binary tree," the absolute difference in height between the left and right subtrees of any node does not exceed 1.
+
+![Balanced binary tree](binary_tree.assets/balanced_binary_tree.png){ class="animation-figure" }
+
+<p align="center"> Figure 7-7 &nbsp; Balanced binary tree </p>
+
+## 7.1.4 &nbsp; Degeneration of binary trees
+
+The Figure 7-8  shows the ideal and degenerate structures of binary trees. When every level of a binary tree is filled, it reaches the "perfect binary tree"; when all nodes are biased towards one side, the binary tree degenerates into a "linked list".
+
+- The perfect binary tree is the ideal situation, fully leveraging the "divide and conquer" advantage of binary trees.
+- A linked list is another extreme, where operations become linear, degrading the time complexity to $O(n)$.
+
+![The Best and Worst Structures of Binary Trees](binary_tree.assets/binary_tree_best_worst_cases.png){ class="animation-figure" }
+
+<p align="center"> Figure 7-8 &nbsp; The Best and Worst Structures of Binary Trees </p>
+
+As shown in the Table 7-1 , in the best and worst structures, the number of leaf nodes, total number of nodes, and height of the binary tree reach their maximum or minimum values.
+
+<p align="center"> Table 7-1 &nbsp; The Best and Worst Structures of Binary Trees </p>
+
+<div class="center-table" markdown>
+
+|                                                 | Perfect binary tree | Linked list |
+| ----------------------------------------------- | ------------------- | ----------- |
+| Number of nodes at level $i$                    | $2^{i-1}$           | $1$         |
+| Number of leaf nodes in a tree with height $h$  | $2^h$               | $1$         |
+| Total number of nodes in a tree with height $h$ | $2^{h+1} - 1$       | $h + 1$     |
+| Height of a tree with $n$ total nodes           | $\log_2 (n+1) - 1$  | $n - 1$     |
+
+</div>
--- a/en/docs/chapter_tree/binary_tree_traversal.md
+++ b/en/docs/chapter_tree/binary_tree_traversal.md
--- a/en/docs/chapter_tree/index.md
+++ b/en/docs/chapter_tree/index.md
@ -0,0 +1,23 @@
+---
+comments: true
+icon: material/graph-outline
+---
+
+# Chapter 7. &nbsp; Tree
+
+![Tree](../assets/covers/chapter_tree.jpg){ class="cover-image" }
+
+!!! abstract
+
+    The towering tree, full of vitality with its roots deep and leaves lush, branches spreading wide.
+    
+    It vividly demonstrates the form of data divide-and-conquer.
+
+## Chapter Contents
+
+- [7.1 &nbsp; Binary Tree](https://www.hello-algo.com/en/chapter_tree/binary_tree/)
+- [7.2 &nbsp; Binary Tree Traversal](https://www.hello-algo.com/en/chapter_tree/binary_tree_traversal/)
+- [7.3 &nbsp; Array Representation of Tree](https://www.hello-algo.com/en/chapter_tree/array_representation_of_tree/)
+- [7.4 &nbsp; Binary Search Tree](https://www.hello-algo.com/en/chapter_tree/binary_search_tree/)
+- [7.5 &nbsp; AVL Tree *](https://www.hello-algo.com/en/chapter_tree/avl_tree/)
+- [7.6 &nbsp; Summary](https://www.hello-algo.com/en/chapter_tree/summary/)
--- a/en/docs/chapter_tree/summary.md
+++ b/en/docs/chapter_tree/summary.md
@ -0,0 +1,58 @@
+---
+comments: true
+---
+
+# 7.6 &nbsp; Summary
+
+### 1. &nbsp; Key review
+
+- A binary tree is a non-linear data structure that reflects the "divide and conquer" logic of splitting one into two. Each binary tree node contains a value and two pointers, which point to its left and right child nodes, respectively.
+- For a node in a binary tree, the tree formed by its left (right) child node and all nodes under it is called the node's left (right) subtree.
+- Related terminology of binary trees includes root node, leaf node, level, degree, edge, height, and depth, among others.
+- The operations of initializing a binary tree, inserting nodes, and removing nodes are similar to those of linked list operations.
+- Common types of binary trees include perfect binary trees, complete binary trees, full binary trees, and balanced binary trees. The perfect binary tree represents the ideal state, while the linked list is the worst state after degradation.
+- A binary tree can be represented using an array by arranging the node values and empty slots in a level-order traversal sequence and implementing pointers based on the index mapping relationship between parent nodes and child nodes.
+- The level-order traversal of a binary tree is a breadth-first search method, which reflects a layer-by-layer traversal manner of "expanding circle by circle." It is usually implemented using a queue.
+- Pre-order, in-order, and post-order traversals are all depth-first search methods, reflecting the traversal manner of "going to the end first, then backtracking to continue." They are usually implemented using recursion.
+- A binary search tree is an efficient data structure for element searching, with the time complexity of search, insert, and remove operations all being $O(\log n)$. When a binary search tree degrades into a linked list, these time complexities deteriorate to $O(n)$.
+- An AVL tree, also known as a balanced binary search tree, ensures that the tree remains balanced after continuous node insertions and removals through rotation operations.
+- Rotation operations in an AVL tree include right rotation, left rotation, right-then-left rotation, and left-then-right rotation. After inserting or removing nodes, an AVL tree performs rotation operations from bottom to top to rebalance the tree.
+
+### 2. &nbsp; Q & A
+
+**Q**: For a binary tree with only one node, are both the height of the tree and the depth of the root node $0$?
+
+Yes, because height and depth are typically defined as "the number of edges passed."
+
+**Q**: The insertion and removal in a binary tree are generally completed by a set of operations. What does "a set of operations" refer to here? Can it be understood as the release of resources of the child nodes?
+
+Taking the binary search tree as an example, the operation of removing a node needs to be handled in three different scenarios, each requiring multiple steps of node operations.
+
+**Q**: Why are there three sequences: pre-order, in-order, and post-order for DFS traversal of a binary tree, and what are their uses?
+
+Similar to sequential and reverse traversal of arrays, pre-order, in-order, and post-order traversals are three methods of traversing a binary tree, allowing us to obtain a traversal result in a specific order. For example, in a binary search tree, since the node sizes satisfy `left child node value < root node value < right child node value`, we can obtain an ordered node sequence by traversing the tree in the "left → root → right" priority.
+
+**Q**: In a right rotation operation that deals with the relationship between the imbalance nodes `node`, `child`, `grand_child`, isn't the connection between `node` and its parent node and the original link of `node` lost after the right rotation?
+
+We need to view this problem from a recursive perspective. The `right_rotate(root)` operation passes the root node of the subtree and eventually returns the root node of the rotated subtree with `return child`. The connection between the subtree's root node and its parent node is established after this function returns, which is outside the scope of the right rotation operation's maintenance.
+
+**Q**: In C++, functions are divided into `private` and `public` sections. What considerations are there for this? Why are the `height()` function and the `updateHeight()` function placed in `public` and `private`, respectively?
+
+It depends on the scope of the method's use. If a method is only used within the class, then it is designed to be `private`. For example, it makes no sense for users to call `updateHeight()` on their own, as it is just a step in the insertion or removal operations. However, `height()` is for accessing node height, similar to `vector.size()`, thus it is set to `public` for use.
+
+**Q**: How do you build a binary search tree from a set of input data? Is the choice of root node very important?
+
+Yes, the method for building the tree is provided in the `build_tree()` method in the binary search tree code. As for the choice of the root node, we usually sort the input data and then select the middle element as the root node, recursively building the left and right subtrees. This approach maximizes the balance of the tree.
+
+**Q**: In Java, do you always have to use the `equals()` method for string comparison?
+
+In Java, for primitive data types, `==` is used to compare whether the values of two variables are equal. For reference types, the working principles of the two symbols are different.
+
+- `==`: Used to compare whether two variables point to the same object, i.e., whether their positions in memory are the same.
+- `equals()`: Used to compare whether the values of two objects are equal.
+
+Therefore, to compare values, we should use `equals()`. However, strings initialized with `String a = "hi"; String b = "hi";` are stored in the string constant pool and point to the same object, so `a == b` can also be used to compare the contents of two strings.
+
+**Q**: Before reaching the bottom level, is the number of nodes in the queue $2^h$ in breadth-first traversal?
+
+Yes, for example, a full binary tree with height $h = 2$ has a total of $n = 7$ nodes, then the bottom level has $4 = 2^h = (n + 1) / 2$ nodes.