Given an array S of n integers, are there elements a, b, c in S such that a + b + c = 0? Find all unique triplets in the array which gives the sum of zero.

Note: The solution set must not contain duplicate triplets.

For example：
given array S = [-1, 0, 1, 2, -1, -4],

A solution set is:

[ [-1, 0, 1], [-1, -1, 2] ]

普通解法

这道题最大难点在于速度上，这个算法通过了281个测试，时间复杂度为O(n^3)，实际运行肯定要超时，总结了下：

1. 使用前要排序，不排序必定超时。
2. 不能暴力解法。

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int>> rec2;
        if (true==nums.empty()) {
            rec2.clear();
            return rec2;
        }
        else if(nums.size()<3) {

            rec2.clear();
            return rec2;
        }
        vector<int> rec;
        sort(nums.begin(),nums.end());

        for(int i=0;nums[i]<=0;i++){
            for(int j=int(nums.size())-1;nums[j]>=0 and i<j+1;j--){
                for(int k=i+1;k<j;k++){
                    if((nums[i]+nums[j]+nums[k])==0){
                         rec.push_back(nums[i]);
                         rec.push_back(nums[k]);
                         rec.push_back(nums[j]);
                        switch (nums[i]){
                            case 0:
                                if(nums[j]==0){
                                    rec2.push_back(rec);
                                    return rec2;
                                }
                        }
                         sort(rec.begin(),rec.end());
                         for(vector<int>l:rec2){
                             if(rec==l){
                                 rec.clear();
                                 break;
                             }
                         }
                        if(false==rec.empty()) {
                            rec2.push_back(rec);
                            rec.clear();
                        }

                    }

                }
            }
        }
        return rec2;
    }


};

高级解法

class Solution {
public:
    vector<vector<int>> res;

    vector<vector<int>> threeSum(vector<int>& nums) {
        if(nums.size() < 3) 
            return res;
        sort(nums.begin(), nums.end());   // 排序

        for(int i=0; i<nums.size()-2; ++i) {
            if(i>0 && nums[i]==nums[i-1]) // 相等的跳过
                continue;
            twoSum(nums, i+1, nums.size()-1, nums[i]);
        }
        return res;
    }

    void twoSum(vector<int>& nums, int begin, int end, int target) {
        int i = begin;  // 头指针
        int j = end;    // 尾指针
        while(i < j) {
            if(nums[i]+nums[j]+target==0) {
                vector<int> v;
                v.push_back(target);
                v.push_back(nums[i]);
                v.push_back(nums[j]);
                res.push_back(v);
                while(i<j && nums[i]==nums[i+1]) 
                    ++i;  // 相等的跳过
                while(i<j && nums[j]==nums[j-1]) 
                    --j;  // 相等的跳过
                ++i;
                --j;
            }
            else if(nums[i]+nums[j]+target<0)
                ++i;
            else
                --j;
        }
    }
};

1. 减少一层循环

这个算法是O(n^2)，它判断了相加后值的大小，如果值为负，说明过于小，移动左边指针（数据从小到大排列）。否则移动右边指针。

else if(nums[i]+nums[j]+target<0)
        ++i;
else
        --j;

普通的解法是用三层循环的嵌套：

    for(int i=0;nums[i]<=0;i++){
            for(int j=int(nums.size())-1;nums[j]>=0 and i<j+1;j--){
                for(int k=i+1;k<j;k++){...}}}

2. 剔除重复

普通解法中，剔除重复的方法是：

 for(vector<int>l:rec2){
       if(rec==l){
       rec.clear();
       break;
       }
   }

这个算法是不考虑数据中是否有重复，每次把相加为0的数据一律放进来，然后再进行遍历检测。
而高级算法中利用了跳过思想解决这个问题：

  while(i<j && nums[i]==nums[i+1]) 
    ++i;  // 相等的跳过
  while(i<j && nums[j]==nums[j-1]) 
    --j;  // 相等的跳过

可能有人会问，如果出现诸如：
-2 -2 4情况，这个程序会不会跳过-2
其实不会跳过，因为重复项我们最多使用两个，比如-2 -2 -2 -2 -2 4 ，会使用两个-2和一个4，如果使用三个，比如-2 -2 -2，显然结果是❌。
基于这个原理，我们只计算一次，便可以跳过所有重复项

总结：

程序中最难的问题是效率问题，如果遇到暴力法，请一定要避免。