Add C++ code for the chapter binary tree.

codes/cpp/chapter_searching/hashing_search.cpp

@@ -40,7 +40,7 @@ int main() {
     cout << "目标元素 3 的索引 = " << index << endl;
 
     /* 哈希查找（链表） */
-    ListNode* head = vectorToLinkedList(nums);
+    ListNode* head = vecToLinkedList(nums);
     // 初始化哈希表
     unordered_map<int, ListNode*> map1;
     while (head != nullptr) {

codes/cpp/chapter_searching/linear_search.cpp

@@ -42,7 +42,7 @@ int main() {
     cout << "目标元素 3 的索引 = " << index << endl;
 
     /* 在链表中执行线性查找 */
-    ListNode* head = vectorToLinkedList(nums);
+    ListNode* head = vecToLinkedList(nums);
     ListNode* node = linearSearch(head, target);
     cout << "目标结点值 3 的对应结点对象为 " << node << endl;
     

codes/cpp/chapter_stack_and_queue/queue.cpp

@@ -6,6 +6,8 @@
 
 #include "../include/include.hpp"
 
+
+/* Driver Code */
 int main(){
     /* 初始化队列 */
     queue<int> queue;

codes/cpp/chapter_stack_and_queue/stack.cpp

@@ -6,7 +6,9 @@
 
 #include "../include/include.hpp"
 
-int main(){
+
+/* Driver Code */
+int main() {
     /* 初始化栈 */
     stack<int> stack;
 
@@ -25,12 +27,12 @@ int main(){
 
     /* 元素出栈 */
     stack.pop();
-    cout<< "出栈元素 pop = " << top << "，出栈后 stack = ";
+    cout << "出栈元素 pop = " << top << "，出栈后 stack = ";
     PrintUtil::printStack(stack);
 
     /* 获取栈的长度 */
     int size = stack.size();
-    cout<< "栈的长度 size = " << size << endl;
+    cout << "栈的长度 size = " << size << endl;
 
     /* 判断是否为空 */
     bool empty = stack.empty();

codes/cpp/chapter_tree/binary_search_tree.cpp

@@ -6,3 +6,149 @@
 
 #include "../include/include.hpp"
 
+/* 二叉搜索树 */
+class BinarySearchTree {
+private:
+    TreeNode* root;
+
+public:
+    BinarySearchTree(vector<int> nums) {
+        sort(nums.begin(), nums.end()); // 排序数组
+        root = buildTree(nums, 0, nums.size() - 1);  // 构建二叉搜索树
+    }
+
+    /* 获取二叉树根结点 */
+    TreeNode* getRoot() {
+        return root;
+    }
+
+    /* 构建二叉搜索树 */
+    TreeNode* buildTree(vector<int> nums, int i, int j) {
+        if (i > j) return nullptr;
+        // 将数组中间结点作为根结点
+        int mid = (i + j) / 2;
+        TreeNode* root = new TreeNode(nums[mid]);
+        // 递归建立左子树和右子树
+        root->left = buildTree(nums, i, mid - 1);
+        root->right = buildTree(nums, mid + 1, j);
+        return root;
+    }
+
+    /* 查找结点 */
+    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;
+    }
+
+    /* 插入结点 */
+    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;
+    }
+
+    /* 删除结点 */
+    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;
+    }
+};
+
+
+/* Driver Code */
+int main() {
+    /* 初始化二叉搜索树 */
+    vector<int> nums = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
+    BinarySearchTree* bst = new BinarySearchTree(nums);
+    cout << endl << "初始化的二叉树为\n" << endl;
+    PrintUtil::printTree(bst->getRoot());
+
+    /* 查找结点 */
+    TreeNode* node = bst->search(5);
+    cout << endl << "查找到的结点对象为 " << node << "，结点值 = " << node->val << endl;
+
+    /* 插入结点 */
+    node = bst->insert(16);
+    cout << endl << "插入结点 16 后，二叉树为\n" << endl;
+    PrintUtil::printTree(bst->getRoot());
+
+    /* 删除结点 */
+    bst->remove(1);
+    cout << endl << "删除结点 1 后，二叉树为\n" << endl;
+    PrintUtil::printTree(bst->getRoot());
+    bst->remove(2);
+    cout << endl << "删除结点 2 后，二叉树为\n" << endl;
+    PrintUtil::printTree(bst->getRoot());
+    bst->remove(4);
+    cout << endl << "删除结点 4 后，二叉树为\n" << endl;
+    PrintUtil::printTree(bst->getRoot());
+
+    return 0;
+}

codes/cpp/chapter_tree/binary_tree.cpp

@@ -6,3 +6,35 @@
 
 #include "../include/include.hpp"
 
+
+/* Driver Code */
+int main() {
+    /* 初始化二叉树 */
+    // 初始化结点
+    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;
+    cout << endl << "初始化二叉树\n" << endl;
+    PrintUtil::printTree(n1);
+
+    /* 插入与删除结点 */
+    TreeNode* P = new TreeNode(0);
+    // 在 n1 -> n2 中间插入结点 P
+    n1->left = P;
+    P->left = n2;
+    cout << endl << "插入结点 P 后\n" << endl;
+    PrintUtil::printTree(n1);
+    // 删除结点 P
+    n1->left = n2;
+    cout << endl << "删除结点 P 后\n" << endl;
+    PrintUtil::printTree(n1);
+
+    return 0;
+}

codes/cpp/chapter_tree/binary_tree_bfs.cpp

@@ -6,3 +6,39 @@
 
 #include "../include/include.hpp"
 
+/* 层序遍历 */
+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;
+}
+
+
+/* Driver Code */
+int main() {
+    /* 初始化二叉树 */
+    // 这里借助了一个从数组直接生成二叉树的函数
+    TreeNode* root = vecToTree(vector<int> 
+        { 1, 2, 3, 4, 5, 6, 7, INT_MAX, INT_MAX, INT_MAX, INT_MAX, INT_MAX, INT_MAX, INT_MAX, INT_MAX });
+    cout << endl << "初始化二叉树\n" << endl;
+    PrintUtil::printTree(root);
+
+    /* 层序遍历 */
+    vector<int> vec = hierOrder(root);
+    cout << endl << "层序遍历的结点打印序列 = ";
+    PrintUtil::printVector(vec);
+
+    return 0;
+}

codes/cpp/chapter_tree/binary_tree_dfs.cpp

@@ -6,3 +6,63 @@
 
 #include "../include/include.hpp"
 
+// 初始化列表，用于存储遍历序列
+vector<int> vec;
+
+/* 前序遍历 */
+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);
+}
+
+
+/* Driver Code */
+int main() {
+    /* 初始化二叉树 */
+    // 这里借助了一个从数组直接生成二叉树的函数
+    TreeNode* root = vecToTree(vector<int> 
+        { 1, 2, 3, 4, 5, 6, 7, INT_MAX, INT_MAX, INT_MAX, INT_MAX, INT_MAX, INT_MAX, INT_MAX, INT_MAX});
+    cout << endl << "初始化二叉树\n" << endl;
+    PrintUtil::printTree(root);
+
+    /* 前序遍历 */
+    vec.clear();
+    preOrder(root);
+    cout << endl << "前序遍历的结点打印序列 = ";
+    PrintUtil::printVector(vec);
+
+    /* 中序遍历 */
+    vec.clear();
+    inOrder(root);
+    cout << endl << "中序遍历的结点打印序列 = ";
+    PrintUtil::printVector(vec);
+
+    /* 后序遍历 */
+    vec.clear();
+    postOrder(root);
+    cout << endl << "后序遍历的结点打印序列 = ";
+    PrintUtil::printVector(vec);
+    
+    return 0;
+}

codes/cpp/include/ListNode.hpp

@@ -25,7 +25,7 @@ struct ListNode {
  * @param list 
  * @return ListNode* 
  */
-ListNode* vectorToLinkedList(vector<int>& list) {
+ListNode* vecToLinkedList(vector<int> list) {
     ListNode *dum = new ListNode(0);
     ListNode *head = dum;
     for (int val : list) {

codes/cpp/include/PrintUtil.hpp

@@ -238,4 +238,27 @@ class PrintUtil {
             }
             cout << "[" + s.str() + "]" << '\n';
         }
+
+        /**
+         * @brief 
+         * 
+         * @tparam T 
+         * @param queue 
+         */
+        template <typename T>
+        static void printQueue(queue<T> &queue)
+        {
+            // Generate the string to print
+            ostringstream s;
+            bool flag = true;
+            while(!queue.empty()) {
+                if (flag) {
+                    s << queue.front();
+                    flag = false;
+                }
+                else s << ", " << queue.front();
+                queue.pop();
+            }
+            cout << "[" + s.str() + "]" << '\n';
+        }
 };

codes/cpp/include/TreeNode.hpp

@@ -23,7 +23,7 @@ struct TreeNode {
  * @param list 
  * @return TreeNode* 
  */
-TreeNode* vectorToTree(vector<int>& list) {
+TreeNode* vecToTree(vector<int> list) {
     TreeNode *root = new TreeNode(list[0]);
     queue<TreeNode*> que;
     que.emplace(root);

codes/java/chapter_tree/binary_search_tree.java

@@ -9,6 +9,7 @@ package chapter_tree;
 import java.util.*;
 import include.*;
 
+/* 二叉搜索树 */
 class BinarySearchTree {
     private TreeNode root;
 

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"
+=== "Java"
-TreeNode P = new TreeNode(0);
+
-// 在 n1 -> n2 中间插入结点 P
+    ```java title="binary_tree.java"
-n1.left = P;
+    TreeNode P = new TreeNode(0);
-P.left = n2;
+    // 在 n1 -> n2 中间插入结点 P
-// 删除结点 P
+    n1.left = P;
-n1.left = n2;
+    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
 
     使用循环一样可以实现前、中、后序遍历，但代码相对繁琐，有兴趣的同学可以自行实现。