Add C++ code for the chapter binary tree.

docs/chapter_tree/binary_search_tree.md

@@ -59,12 +59,43 @@ comments: true
     }
     ```
 
+=== "C++"
+
+    ```cpp title="binary_search_tree.cpp"
+    /* 查找结点 */
+    TreeNode* search(int num) {
+        TreeNode* cur = root;
+        // 循环查找，越过叶结点后跳出
+        while (cur != nullptr) {
+            // 目标结点在 root 的右子树中
+            if (cur->val < num) cur = cur->right;
+            // 目标结点在 root 的左子树中
+            else if (cur->val > num) cur = cur->left;
+            // 找到目标结点，跳出循环
+            else break;
+        }
+        // 返回目标结点
+        return cur;
+    }
+    ```
+
+=== "Python"
+
+    ```python title="binary_search_tree.py"
+
+    ```
+
+=== "Go"
+
+    ```go title="binary_search_tree.go"
+
+    ```
+
 ### 插入结点
 
 给定一个待插入元素 `num` ，为了保持二叉搜索树 “左子树 < 根结点 < 右子树” 的性质，插入操作分为两步：
 
 1. **查找插入位置：** 与查找操作类似，我们从根结点出发，根据当前结点值和 `num` 的大小关系循环向下搜索，直到越过叶结点（遍历到 $\text{null}$ ）时跳出循环；
-
 2. **在该位置插入结点：** 初始化结点 `num` ，将该结点放到 $\text{null}$ 的位置 ；
 
 二叉搜索树不允许存在重复结点，否则将会违背其定义。因此若待插入结点在树中已经存在，则不执行插入，直接返回即可。
@@ -97,6 +128,44 @@ comments: true
     }
     ```
 
+=== "C++"
+
+    ```cpp title="binary_search_tree.cpp"
+    /* 插入结点 */
+    TreeNode* insert(int num) {
+        // 若树为空，直接提前返回
+        if (root == nullptr) return nullptr;
+        TreeNode *cur = root, *pre = nullptr;
+        // 循环查找，越过叶结点后跳出
+        while (cur != nullptr) {
+            // 找到重复结点，直接返回
+            if (cur->val == num) return nullptr;
+            pre = cur;
+            // 插入位置在 root 的右子树中
+            if (cur->val < num) cur = cur->right;
+            // 插入位置在 root 的左子树中
+            else cur = cur->left;
+        }
+        // 插入结点 val
+        TreeNode* node = new TreeNode(num);
+        if (pre->val < num) pre->right = node;
+        else pre->left = node;
+        return node;
+    }
+    ```
+
+=== "Python"
+
+    ```python title="binary_search_tree.py"
+
+    ```
+
+=== "Go"
+
+    ```go title="binary_search_tree.go"
+
+    ```
+
 为了插入结点，需要借助 **辅助结点 `prev`** 保存上一轮循环的结点，这样在遍历到 $\text{null}$ 时，我们也可以获取到其父结点，从而完成结点插入操作。
 
 与查找结点相同，插入结点使用 $O(\log n)$ 时间。
@@ -188,6 +257,69 @@ comments: true
     }
     ```
 
+=== "C++"
+
+    ```cpp title="binary_search_tree.cpp"
+    /* 删除结点 */
+    TreeNode* remove(int num) {
+        // 若树为空，直接提前返回
+        if (root == nullptr) return nullptr;
+        TreeNode *cur = root, *pre = nullptr;
+        // 循环查找，越过叶结点后跳出
+        while (cur != nullptr) {
+            // 找到待删除结点，跳出循环
+            if (cur->val == num) break;
+            pre = cur;
+            // 待删除结点在 root 的右子树中
+            if (cur->val < num) cur = cur->right;
+            // 待删除结点在 root 的左子树中
+            else cur = cur->left;
+        }
+        // 若无待删除结点，则直接返回
+        if (cur == nullptr) return nullptr;
+        // 子结点数量 = 0 or 1
+        if (cur->left == nullptr || cur->right == nullptr) {
+            // 当子结点数量 = 0 / 1 时， child = nullptr / 该子结点
+            TreeNode* child = cur->left != nullptr ? cur->left : cur->right;
+            // 删除结点 cur
+            if (pre->left == cur) pre->left = child;
+            else pre->right = child;
+        }
+        // 子结点数量 = 2
+        else {
+            // 获取中序遍历中 cur 的下一个结点
+            TreeNode* nex = min(cur->right);
+            int tmp = nex->val;
+            // 递归删除结点 nex
+            remove(nex->val);
+            // 将 nex 的值复制给 cur
+            cur->val = tmp;
+        }
+        return cur;
+    }
+    /* 获取最小结点 */
+    TreeNode* min(TreeNode* root) {
+        if (root == nullptr) return root;
+        // 循环访问左子结点，直到叶结点时为最小结点，跳出
+        while (root->left != nullptr) {
+            root = root->left;
+        }
+        return root;
+    }
+    ```
+
+=== "Python"
+
+    ```python title="binary_search_tree.py"
+
+    ```
+
+=== "Go"
+
+    ```go title="binary_search_tree.go"
+
+    ```
+
 ## 二叉搜索树的优势
 
 假设给定 $n$ 个数字，最常用的存储方式是「数组」，那么对于这串乱序的数字，常见操作的效率为：

docs/chapter_tree/binary_tree.md

@@ -18,6 +18,35 @@ comments: true
     }
     ```
 
+=== "C++"
+
+    ```cpp
+    /* 链表结点结构体 */
+    struct TreeNode {
+        int val;          // 结点值
+        TreeNode *left;   // 左子结点指针
+        TreeNode *right;  // 右子结点指针
+        TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+    };
+    ```
+
+=== "Python"
+
+    ```python
+    """ 链表结点类 """
+    class TreeNode:
+        def __init__(self, val=0, left=None, right=None):
+            self.val = val      # 结点值
+            self.left = left    # 左子结点指针
+            self.right = right  # 右子结点指针
+    ```
+
+=== "Go"
+
+    ```go
+
+    ```
+
 结点的两个指针分别指向「左子结点 Left Child Node」和「右子结点 Right Child Node」，并且称该结点为两个子结点的「父结点 Parent Node」。给定二叉树某结点，将左子结点以下的树称为该结点的「左子树 Left Subtree」，右子树同理。
 
 ![binary_tree_definition](binary_tree.assets/binary_tree_definition.png)
@@ -84,20 +113,75 @@ comments: true
     n2.right = n5;
     ```
 
+=== "C++"
+
+    ```cpp title="binary_tree.cpp"
+    /* 初始化二叉树 */
+    // 初始化结点
+    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);
+    // 构建引用指向（即指针）
+    n1->left = n2;
+    n1->right = n3;
+    n2->left = n4;
+    n2->right = n5;
+    ```
+
+=== "Python"
+
+    ```python title="binary_tree.py"
+
+    ```
+
+=== "Go"
+
+    ```go title="binary_tree.go"
+
+    ```
+
 **插入与删除结点。** 与链表类似，插入与删除结点都可以通过修改指针实现。
 
 ![binary_tree_add_remove](binary_tree.assets/binary_tree_add_remove.png)
 
 <p align="center"> Fig. 在二叉树中插入与删除结点 </p>
 
-```java title="binary_tree.java"
-TreeNode P = new TreeNode(0);
-// 在 n1 -> n2 中间插入结点 P
-n1.left = P;
-P.left = n2;
-// 删除结点 P
-n1.left = n2;
-```
+=== "Java"
+
+    ```java title="binary_tree.java"
+    TreeNode P = new TreeNode(0);
+    // 在 n1 -> n2 中间插入结点 P
+    n1.left = P;
+    P.left = n2;
+    // 删除结点 P
+    n1.left = n2;
+    ```
+
+=== "C++"
+
+    ```cpp title="binary_tree.cpp"
+    /* 插入与删除结点 */
+    TreeNode* P = new TreeNode(0);
+    // 在 n1 -> n2 中间插入结点 P
+    n1->left = P;
+    P->left = n2;
+    // 删除结点 P
+    n1->left = n2;
+    ```
+
+=== "Python"
+
+    ```python title="binary_tree.py"
+
+    ```
+
+=== "Go"
+
+    ```go title="binary_tree.go"
+
+    ```
 
 !!! note
 
@@ -140,6 +224,41 @@ n1.left = n2;
     }
     ```
 
+=== "C++"
+
+    ```cpp title="binary_tree_bfs.cpp"
+    /* 层序遍历 */
+    vector<int> hierOrder(TreeNode* root) {
+        // 初始化队列，加入根结点
+        queue<TreeNode*> queue;
+        queue.push(root);
+        // 初始化一个列表，用于保存遍历序列
+        vector<int> vec;
+        while (!queue.empty()) {
+            TreeNode* node = queue.front();
+            queue.pop();  // 队列出队
+            vec.push_back(node->val);            // 保存结点
+            if (node->left != NULL)
+                queue.push(node->left);    // 左子结点入队
+            if (node->right != NULL)
+                queue.push(node->right);   // 右子结点入队
+        }
+        return vec;
+    }
+    ```
+
+=== "Python"
+
+    ```python title="binary_tree_bfs.py"
+
+    ```
+
+=== "Go"
+
+    ```go title="binary_tree_bfs.go"
+
+    ```
+
 ### 前序、中序、后序遍历
 
 相对地，前、中、后序遍历皆属于「深度优先遍历 Depth-First Traversal」，其体现着一种 “先走到尽头，再回头继续” 的回溯遍历方式。
@@ -191,6 +310,49 @@ n1.left = n2;
     }
     ```
 
+=== "C++"
+
+    ```cpp title="binary_tree_dfs.cpp"
+    /* 前序遍历 */
+    void preOrder(TreeNode* root) {
+        if (root == nullptr) return;
+        // 访问优先级：根结点 -> 左子树 -> 右子树
+        vec.push_back(root->val);
+        preOrder(root->left);
+        preOrder(root->right);
+    }
+
+    /* 中序遍历 */
+    void inOrder(TreeNode* root) {
+        if (root == nullptr) return;
+        // 访问优先级：左子树 -> 根结点 -> 右子树
+        inOrder(root->left);
+        vec.push_back(root->val);
+        inOrder(root->right);
+    }
+
+    /* 后序遍历 */
+    void postOrder(TreeNode* root) {
+        if (root == nullptr) return;
+        // 访问优先级：左子树 -> 右子树 -> 根结点
+        postOrder(root->left);
+        postOrder(root->right);
+        vec.push_back(root->val);
+    }
+    ```
+
+=== "Python"
+
+    ```python title="binary_tree_dfs.py"
+
+    ```
+
+=== "Go"
+
+    ```go title="binary_tree_dfs.go"
+
+    ```
+
 !!! note
 
     使用循环一样可以实现前、中、后序遍历，但代码相对繁琐，有兴趣的同学可以自行实现。