• 15.三数之和 :::info 注意[0， 0， 0， 0] 这组数据
      答案中不可以包含重复的三元组。，这个意思指的是计算结果中不能有一样的三元组，什么时候会出一样的呢，就是在计算过程中，有相邻的符合表达式的元素，所以要对相邻元素去重。 ::: 有个疑问，为什么不直接用set来排序去重，看了一圈答案，好像是会超时，而且set只能用find函数，也崩直接用双指针下标。
      代码：（详细注释）

    哈希法，根本看不懂。。。

    1. class Solution {
    2. public:
    3.     vector<vector<int>> threeSum(vector<int>& nums) {
    4.         vector<vector<int>> result;
    5.         sort(nums.begin(), nums.end());
    6.         // 找出a + b + c = 0
    7.         // a = nums[i], b = nums[j], c = -(a + b)
    8.         for (int i = 0; i < nums.size(); i++) {
    9.             // 排序之后如果第一个元素已经大于零，那么不可能凑成三元组
    10.             if (nums[i] > 0) {
    11.                 continue;
    12.             }
    13.             if (i > 0 && nums[i] == nums[i - 1]) { //三元组元素a去重
    14.                 continue;
    15.             }
    16.             unordered_set<int> set;
    17.             for (int j = i + 1; j < nums.size(); j++) {
    18.                 if (j > i + 2
    19.                         && nums[j] == nums[j-1]
    20.                         && nums[j-1] == nums[j-2]) { // 三元组元素b去重
    21.                     continue;
    22.                 }
    23.                 int c = 0 - (nums[i] + nums[j]);
    24.                 if (set.find(c) != set.end()) {
    25.                     result.push_back({nums[i], nums[j], c});
    26.                     set.erase(c);// 三元组元素c去重
    27.                 } else {
    28.                     set.insert(nums[j]);
    29.                 }
    30.             }
    31.         }
    32.         return result;
    33.     }
    34. };

    正确应该用双指针的办法
    三数之和 - 图1

    1. class Solution {
    2. public:
    3.     vector<vector<int>> threeSum(vector<int>& nums) {
    4.         vector<vector<int>> result;
    5.         sort(nums.begin(), nums.end());
    6.         // 找出a + b + c = 0
    7.         // a = nums[i], b = nums[left], c = nums[right]
    8.         for (int i = 0; i < nums.size(); i++) {
    9.             // 排序之后如果第一个元素已经大于零，那么无论如何组合都不可能凑成三元组，直接返回结果就可以了
    10.             if (nums[i] > 0) {
    11.                 return result;
    12.             }
    13.             // 错误去重方法，将会漏掉-1,-1,2 这种情况
    14.             /*
    15.             if (nums[i] == nums[i + 1]) {
    16.                 continue;
    17.             }
    18.             */
    19.             // 正确去重方法
    20.             if (i > 0 && nums[i] == nums[i - 1]) {
    21.                 continue;
    22.             }
    23.             int left = i + 1;
    24.             int right = nums.size() - 1;
    25.             while (right > left) {
    26.                 // 去重复逻辑如果放在这里，0，0，0 的情况，可能直接导致 right<=left 了，从而漏掉了 0,0,0 这种三元组
    27.                 /*
    28.                 while (right > left && nums[right] == nums[right - 1]) right--;
    29.                 while (right > left && nums[left] == nums[left + 1]) left++;
    30.                 */
    31.                 if (nums[i] + nums[left] + nums[right] > 0) {
    32.                     right--;
    33.                 } else if (nums[i] + nums[left] + nums[right] < 0) {
    34.                     left++;
    35.                 } else {
    36.                     result.push_back(vector<int>{nums[i], nums[left], nums[right]});
    37.                     // 去重逻辑应该放在找到一个三元组之后
    38.                     while (right > left && nums[right] == nums[right - 1]) right--;
    39.                     while (right > left && nums[left] == nums[left + 1]) left++;
    41.                     // 找到答案时，双指针同时收缩
    42.                     right--;
    43.                     left++;
    44.                 }
    45.             }
    47.         }
    48.         return result;
    49.     }
    50. };

    分析：
    经典