to: 添加注释

Author: yi-ge

src/sort/largest_positive_integer_that_exists_with_its_negative.cpp

@@ -6,18 +6,24 @@
 
 class Solution {
 public:
+  // 寻找最大的k，使得-k存在于nums中
   int findMaxK(vector<int> &nums) {
+    // 从小到大排序
     std::sort(nums.begin(), nums.end());
     int max_k = -1;
     int i = 0;
     int j = nums.size() - 1;
+    // 双指针寻找最大的k
     while (i < j) {
       if (nums[i] + nums[j] == 0) {
+        // 如果i和j的和为0，则说明-k存在于nums中，返回j即可
         max_k = nums[j];
         break;
       } else if (nums[i] + nums[j] < 0) {
+        // 如果i和j的和小于0，则说明i需要向右移动
         i++;
       } else {
+        // 如果i和j的和大于0，则说明j需要向左移动
         j--;
       }
     }

src/sort/largest_values_from_labels.cpp

@@ -5,28 +5,40 @@
 
 class Solution {
 public:
+  // 求出从values中选numWanted个数的最大值，其中每个数有对应的标签labels，
+  // 每个标签最多只能使用useLimit次
   int largestValsFromLabels(vector<int> &values, vector<int> &labels,
                             int numWanted, int useLimit) {
+    // 将values和labels组合成pair放到vector中
     vector<pair<int, int>> v;
     for (int i = 0; i < values.size(); ++i) {
       v.push_back({values[i], labels[i]});
     }
+    // 根据values中的大小进行排序
     sort(v.begin(), v.end(),
          [](const pair<int, int> &a, const pair<int, int> &b) {
            return a.first > b.first;
          });
+    // 使用unordered_map记录每个标签已经使用的次数
     unordered_map<int, int> m;
     int res = 0;
+    // 遍历排序后的vector
     for (int i = 0; i < v.size(); ++i) {
+      // 如果当前标签还可以使用
       if (m[v[i].second] < useLimit) {
+        // 记录当前选中的数的和
         res += v[i].first;
+        // 将当前标签的使用次数加1
         ++m[v[i].second];
+        // 将还需要选的数量减1
         --numWanted;
       }
+      // 如果已经选够了numWanted个数，则直接退出循环
       if (numWanted == 0) {
         break;
       }
     }
+    // 返回选中数的和
     return res;
   }
 };

src/sort/make_array_strictly_increasing.cpp

@@ -9,31 +9,31 @@ constexpr int INF = 0x3f3f3f3f;
 class Solution {
 public:
   int makeArrayIncreasing(vector<int> &arr1, vector<int> &arr2) {
-    sort(arr2.begin(), arr2.end());
-    arr2.erase(unique(arr2.begin(), arr2.end()), arr2.end());
+    sort(arr2.begin(), arr2.end()); // 对 arr2 排序
+    arr2.erase(unique(arr2.begin(), arr2.end()), arr2.end()); // 去重
     int n = arr1.size();
     int m = arr2.size();
-    vector<vector<int>> dp(n + 1, vector<int>(min(m, n) + 1, INF));
-    dp[0][0] = -1;
+    vector<vector<int>> dp(n + 1, vector<int>(min(m, n) + 1, INF)); // 定义状态数组
+    dp[0][0] = -1; // 初始化
     for (int i = 1; i <= n; i++) {
       for (int j = 0; j <= min(i, m); j++) {
         /* 如果当前元素大于序列的最后一个元素 */
         if (arr1[i - 1] > dp[i - 1][j]) {
-          dp[i][j] = arr1[i - 1];
+          dp[i][j] = arr1[i - 1]; // 直接将当前元素加入序列
         }
         if (j > 0 && dp[i - 1][j - 1] != INF) {
           /* 查找严格大于 dp[i - 1][j - 1] 的最小元素 */
           auto it =
               upper_bound(arr2.begin() + j - 1, arr2.end(), dp[i - 1][j - 1]);
           if (it != arr2.end()) {
-            dp[i][j] = min(dp[i][j], *it);
+            dp[i][j] = min(dp[i][j], *it); // 将找到的元素加入序列
           }
         }
         if (i == n && dp[i][j] != INF) {
-          return j;
+          return j; // 返回最小的可以使数组严格递增的操作次数
         }
       }
     }
-    return -1;
+    return -1; // 无法使数组严格递增
   }
 };

src/sort/merge_sort.cpp

@@ -5,31 +5,40 @@
 class Solution
 {
 public:
+  // 归并排序函数，返回排序后的数组
   vector<int> mergeSort(vector<int> &nums)
   {
+    // 数组大小小于等于1时直接返回
     if (nums.size() <= 1)
       return nums;
+    // 找到数组中间位置
     int halfIndex = floor(nums.size() / 2);
+    // 将左半部分赋值给left
     vector<int> left;
     left.assign(nums.begin(), nums.begin() + halfIndex);
-
+    // 将右半部分赋值给right
     vector<int> right;
     right.assign(nums.begin() + halfIndex, nums.end());
-
+    // 递归调用归并排序函数对左右两部分分别排序
     vector<int> leftSort = mergeSort(left);
     vector<int> rightSort = mergeSort(right);
+    // 将排序后的左右两部分合并
     return marge(leftSort, rightSort);
   }
 
 private:
+  // 合并两个有序数组为一个有序数组
   vector<int> marge(vector<int> &left, vector<int> &right)
   {
     vector<int> res;
+    // 当左右两个数组都不为空时
     while (left.size() > 0 && right.size() > 0)
     {
+      // 将左右两个数组中较小的元素加入结果数组中
       if (left[0] < right[0])
       {
         res.push_back(left[0]);
+        // 删除已经加入结果数组的元素
         vector<int>::iterator k = left.begin();
         left.erase(k);
       }
@@ -40,6 +49,7 @@ class Solution
         right.erase(j);
       }
     }
+    // 将左右两个数组中剩余的元素加入结果数组中
     res.insert(res.end(), left.begin(), left.end());
     res.insert(res.end(), right.begin(), right.end());
     return res;

src/sort/moving_stones_until_consecutive_ii.cpp

@@ -6,23 +6,24 @@
 class Solution {
 public:
   vector<int> numMovesStonesII(vector<int> &stones) {
-    sort(stones.begin(), stones.end());
+    sort(stones.begin(), stones.end()); // 将石头位置从小到大排序
     int n = stones.size();
-    int maxn = max(stones[n - 1] - n + 2 - stones[1],
-                   stones[n - 2] - stones[0] - n + 2);
-    int minn = maxn;
-    int i = 0, j = 0;
+    // 计算最大值
+    int maxn = max(stones[n - 1] - n + 2 - stones[1], // 最右边的石头往左移或最左边的石头往右移
+                   stones[n - 2] - stones[0] - n + 2); // 最右边的石头往左移并且最左边的石头往右移
+    int minn = maxn; // 初始最小值等于最大值
+    int i = 0, j = 0; // 双指针，i指向区间左端点，j指向区间右端点
     while (j < n) {
-      while (stones[j] - stones[i] + 1 > n) {
+      while (stones[j] - stones[i] + 1 > n) { // 区间长度大于等于n时缩小区间
         i++;
       }
-      if (j - i + 1 == n - 1 && stones[j] - stones[i] + 1 == n - 1) {
-        minn = min(minn, 2);
+      if (j - i + 1 == n - 1 && stones[j] - stones[i] + 1 == n - 1) { // 只有一个空位
+        minn = min(minn, 2); // 只需要移动两次
       } else {
-        minn = min(minn, n - (j - i + 1));
+        minn = min(minn, n - (j - i + 1)); // 其他情况最小移动次数为n-区间长度
       }
       j++;
     }
-    return {minn, maxn};
+    return {minn, maxn}; // 返回最小值和最大值
   }
 };

src/sort/quick_sort.cpp

@@ -5,34 +5,39 @@
 class Solution
 {
 public:
+  // 对给定数组进行快速排序
   void quickSort(vector<int> &nums)
   {
     quickSort(nums, 0, nums.size() - 1);
   }
 
 private:
+  // 对数组nums的[l, r]部分进行partition操作，并返回pivot的下标
   int partition(vector<int> &nums, int l, int r)
   {
+    // 选择第一个元素作为pivot
     int v = nums[l];
 
+    // [l+1, j]表示小于v的部分，(j, i]表示大于等于v的部分
     int j = l;
     for (int i = l + 1; i <= r; ++i)
     {
       if (nums[i] < v)
-        swap(nums[i], nums[++j]);
+        swap(nums[i], nums[++j]); // 将小于v的元素交换到[l+1, j]位置
     }
 
-    swap(nums[l], nums[j]);
+    swap(nums[l], nums[j]); // 将pivot交换到正确的位置
 
     return j;
   }
 
+  // 对数组nums的[l, r]部分进行快速排序
   void quickSort(vector<int> &nums, int l, int r)
   {
     if (l >= r)
       return;
-    int j = partition(nums, l, r);
-    quickSort(nums, l, j - 1);
-    quickSort(nums, j + 1, r);
+    int j = partition(nums, l, r); // 对当前部分进行partition操作，得到pivot的下标
+    quickSort(nums, l, j - 1); // 对pivot左侧部分进行递归排序
+    quickSort(nums, j + 1, r); // 对pivot右侧部分进行递归排序
   }
 };

src/sort/widest_vertical_area_between_two_points_containing_no_points.cpp

@@ -7,11 +7,13 @@
 class Solution {
 public:
   int maxWidthOfVerticalArea(vector<vector<int>> &points) {
+    // 将点按照横坐标从小到大排序
     sort(points.begin(), points.end());
-    int maxX = 0;
+    int maxX = 0; // 最大宽度初始为0
+    // 遍历每两个相邻的点，计算它们之间的横坐标差，更新最大宽度
     for (int i = 1; i < points.size(); i++) {
       maxX = max(points[i][0] - points[i - 1][0], maxX);
     }
-    return maxX;
+    return maxX; // 返回最大宽度
   }
 };