to: 添加注释

Author: yi-ge

src/tree/complete_binary_tree_inserter.cpp

@@ -5,12 +5,14 @@
 
 class CBTInserter {
 public:
+  // 构造函数，初始化根节点和候选节点队列
   CBTInserter(TreeNode *root) {
     this->root = root;
 
     queue<TreeNode *> q;
     q.push(root);
 
+    // 遍历树，将没有左右子节点的节点加入候选节点队列
     while (!q.empty()) {
       TreeNode *node = q.front();
       q.pop();
@@ -26,6 +28,7 @@ class CBTInserter {
     }
   }
 
+  // 插入新节点，返回被替换的节点的值
   int insert(int val) {
     TreeNode *child = new TreeNode(val);
     TreeNode *node = candidate.front();
@@ -40,11 +43,12 @@ class CBTInserter {
     return ret;
   } // LCOV_EXCL_LINE
 
+  // 返回根节点
   TreeNode *get_root() { return root; }
 
 private:
-  queue<TreeNode *> candidate;
-  TreeNode *root;
+  queue<TreeNode *> candidate; // 候选节点队列
+  TreeNode *root; // 根节点
 };
 
 /**

src/tree/insert_into_a_binary_search_tree.cpp

@@ -1,6 +1,7 @@
 // 二叉搜索树中的插入操作
 // https://leetcode.cn/problems/insert-into-a-binary-search-tree/
 // INLINE  ../../images/tree/insert_into_a_binary_search_tree.jpeg
+
 #include <headers.hpp>
 
 /**
@@ -15,26 +16,28 @@
  * right(right) {}
  * };
  */
+
 class Solution {
 public:
+  // 插入节点
   TreeNode *insertIntoBST(TreeNode *root, int val) {
     if (root == nullptr) {
       return new TreeNode(val);
     }
     TreeNode *pos = root;
     while (pos != nullptr) {
-      if (val < pos->val) {
-        if (pos->left == nullptr) {
+      if (val < pos->val) { // 待插入节点值小于当前节点值，向左子树寻找插入位置
+        if (pos->left == nullptr) { // 左子树为空，插入节点
           pos->left = new TreeNode(val);
           break;
-        } else {
+        } else { // 左子树不为空，继续向左子树寻找插入位置
           pos = pos->left;
         }
-      } else {
-        if (pos->right == nullptr) {
+      } else { // 待插入节点值大于等于当前节点值，向右子树寻找插入位置
+        if (pos->right == nullptr) { // 右子树为空，插入节点
           pos->right = new TreeNode(val);
           break;
-        } else {
+        } else { // 右子树不为空，继续向右子树寻找插入位置
           pos = pos->right;
         }
       }

src/tree/maximum_difference_between_node_and_ancestor.cpp

@@ -15,32 +15,36 @@
  * right(right) {}
  * };
  */
+
 class Solution {
 public:
-  pair<int, int> dfs(TreeNode *root, int &max_diff) {
-    if (root) {
-      int min_val = root->val, max_val = root->val;
-      if (root->left) {
-        auto [left_min, left_max] = dfs(root->left, max_diff);
-        min_val = min(min_val, left_min);
-        max_val = max(max_val, left_max);
-      }
-      if (root->right) {
-        auto [right_min, right_max] = dfs(root->right, max_diff);
-        min_val = min(min_val, right_min);
-        max_val = max(max_val, right_max);
-      }
-      max_diff = max(max_diff, abs(root->val - min_val));
-      max_diff = max(max_diff, abs(root->val - max_val));
-      return {min_val, max_val};
-    } else {
-      return {INT_MAX, INT_MIN}; // LCOV_EXCL_LINE
+    // 递归函数，返回以当前节点为根的子树的最小值和最大值
+    // 同时更新max_diff
+    pair<int, int> dfs(TreeNode *root, int &max_diff) {
+        if (root) {
+            int min_val = root->val, max_val = root->val;
+            if (root->left) {
+                auto [left_min, left_max] = dfs(root->left, max_diff);
+                min_val = min(min_val, left_min);
+                max_val = max(max_val, left_max);
+            }
+            if (root->right) {
+                auto [right_min, right_max] = dfs(root->right, max_diff);
+                min_val = min(min_val, right_min);
+                max_val = max(max_val, right_max);
+            }
+            max_diff = max(max_diff, abs(root->val - min_val));
+            max_diff = max(max_diff, abs(root->val - max_val));
+            return {min_val, max_val};
+        } else {
+            return {INT_MAX, INT_MIN}; // 空节点返回最大值和最小值
+        }
     }
-  }
 
-  int maxAncestorDiff(TreeNode *root) {
-    int max_diff = 0;
-    dfs(root, max_diff);
-    return max_diff;
-  }
-};
+    // 求最大差值
+    int maxAncestorDiff(TreeNode *root) {
+        int max_diff = 0;
+        dfs(root, max_diff);
+        return max_diff;
+    }
+};

src/tree/maximum_sum_bst_in_binary_tree.cpp

@@ -53,18 +53,23 @@ class Solution {
     int ans = 0;
     const int inf = 1 << 30;
 
+    // dfs函数用于遍历二叉树
     function<vector<int>(TreeNode *)> dfs = [&](TreeNode *root) {
       if (!root) {
+        // 如果节点为空，返回一个全为0的vector
         return vector<int>{1, inf, -inf, 0};
       }
+      // 递归遍历左右子树
       auto l = dfs(root->left);
       auto r = dfs(root->right);
       int v = root->val;
       if (l[0] && r[0] && l[2] < v && v < r[1]) {
+        // 如果当前节点满足二叉搜索树的条件，更新答案并返回一个包含当前节点信息的vector
         int s = l[3] + r[3] + v;
         ans = max(ans, s);
         return vector<int>{1, min(l[1], v), max(r[2], v), s};
       }
+      // 如果当前节点不满足二叉搜索树的条件，直接返回一个全为0的vector
       return vector<int>(4);
     };
     dfs(root);

src/tree/maximum_width_of_binary_tree.cpp

@@ -14,34 +14,36 @@
  *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
  * };
  */
+
+// 解法：二叉树的层序遍历，使用 pair 存储每个节点的 index，index 的计算方法是左子节点 index * 2，右子节点 index * 2 + 1
 class Solution
 {
 public:
   int widthOfBinaryTree(TreeNode *root)
   {
-    unsigned long long ans = 1;
-    vector<pair<TreeNode *, unsigned long long>> arr;
-    arr.emplace_back(root, 1L);
+    unsigned long long ans = 1; // 初始化答案
+    vector<pair<TreeNode *, unsigned long long>> arr; // 使用 pair 存储每个节点的指针和 index
+    arr.emplace_back(root, 1L); // 将根节点和 index = 1 存入数组中
 
-    while (!arr.empty())
+    while (!arr.empty()) // 一直循环直到数组为空
     {
-      vector<pair<TreeNode *, unsigned long long>> temp;
-      for (auto &[node, index] : arr)
+      vector<pair<TreeNode *, unsigned long long>> temp; // 创建临时数组
+      for (auto &[node, index] : arr) // 遍历当前数组的所有节点
       {
-        if (node->left)
+        if (node->left) // 如果有左子节点
         {
-          temp.emplace_back(node->left, index * 2);
+          temp.emplace_back(node->left, index * 2); // 将左子节点和新的 index 存入临时数组
         }
 
-        if (node->right)
+        if (node->right) // 如果有右子节点
         {
-          temp.emplace_back(node->right, index * 2 + 1);
+          temp.emplace_back(node->right, index * 2 + 1); // 将右子节点和新的 index 存入临时数组
         }
       }
-      ans = max(ans, arr.back().second - arr[0].second + 1);
-      arr = move(temp);
+      ans = max(ans, arr.back().second - arr[0].second + 1); // 更新最大宽度
+      arr = move(temp); // 将临时数组赋值给当前数组，进入下一层循环
     }
 
-    return ans;
+    return ans; // 返回最大宽度
   }
 };

src/tree/path_sum.cpp

@@ -15,17 +15,22 @@
  * right(right) {}
  * };
  */
+
 class Solution {
 public:
+  // 判断是否存在从根节点到叶子节点路径和为目标值的路径
   bool hasPathSum(TreeNode *root, int targetSum) {
+    // 空树不满足条件，返回 false
     if (root == nullptr) {
       return false;
     }
 
+    // 只有一个根节点，判断根节点的值是否等于目标值
     if (root->left == nullptr && root->right == nullptr) {
       return targetSum == root->val;
     }
 
+    // 递归判断左子树和右子树是否有满足条件的路径
     return hasPathSum(root->left, targetSum - root->val) ||
            hasPathSum(root->right, targetSum - root->val);
   }

src/tree/time_needed_to_inform_all_employees.cpp

@@ -5,21 +5,29 @@
 
 class Solution {
 public:
+  // 深度优先搜索函数，返回从当前节点通知所有下属所需的最长时间
   int dfs(vector<vector<int>> &tree, vector<int> &informTime, int root) {
     int maxTime = 0;
+    // 遍历当前节点的所有下属
     for (int &sub : tree[root]) {
+      // 递归调用深度优先搜索函数，更新最长时间
       maxTime = max(maxTime, dfs(tree, informTime, sub));
     }
+    // 返回当前节点通知下属所需的时间，加上当前节点本身通知所需的时间
     return maxTime + informTime[root];
   }
+
+  // 计算通知所有员工所需的时间
   int numOfMinutes(int n, int headID, vector<int> &manager,
                    vector<int> &informTime) {
+    // 构建树形结构
     vector<vector<int>> tree(n);
     for (int i = 0; i < n; ++i) {
       if (manager[i] != -1) {
         tree[manager[i]].push_back(i);
       }
     }
+    // 调用深度优先搜索函数，计算通知所有员工所需的时间
     return dfs(tree, informTime, headID);
   }
 };

test/lib/lib_test.cpp

@@ -1,4 +1,4 @@
-// 执行编译时间：2023-06-03 11:50:44
+// 执行编译时间：2023-06-03 17:24:42
 #include <gtest/gtest.h>
 #include <lib.hpp>