leetcode 15. 3Sum

这道题最后各种调整优化，但是就是超时，我也是跪了，所以我觉得根本还是算法的问题，我现在的复杂度是O(n^2logn)所以，感觉复杂度略高。
细细想一下，似乎假设确定了a，那么b和c的和是一定的，又因为是排好序的，所以感觉O(n^2)就可以搞定。

方法1：我的方法

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

//vector<int>::iterator iter = unique(nums.begin(),nums.end());
//nums.erase(iter,nums.end());
/*for(int i=0;i<nums.size();i++){
    cout<<nums[i]<<' ';
}*/
for(int i=0;i<nums.size()-1;++i){
    if(i!=0 && nums[i] == nums[i-1])continue;
    for(int j=i+1;j<nums.size();++j){
        int a = nums[i],b = nums[j];
        int c = -a-b;
        if( (c<a) || (c>b) )continue;
        int left = i,right = j;
        while(left<=right){
            int mid = (left+right)/2;
            if(nums[mid]>c){
                right = mid-1;
            }else{
                left = mid+1;
            }
        }
        while( (right==i || right==j) && right>=0 )right--;

        if( right>=0 && nums[right]==c ){
            vector<int> elem;
            /*elem.push_back(min(a,min(b,c)));
            elem.push_back(0-min(a,min(b,c))-max(a,max(b,c)));
            elem.push_back(max(a,max(b,c)));*/
            elem.push_back(a);
            elem.push_back(c);
            elem.push_back(b);
            ret.push_back(elem);
        }
    }
}
vector<vector<int> >::iterator iter = unique(ret.begin(),ret.end());
ret.erase(iter,ret.end());
return ret;
}

方法2：discuss中找的其他人的方法，就是O(n^2)

public List<List<Integer>> threeSum(int[] nums) {
List<List<Integer>> result = new ArrayList<>();
if(nums == null || nums.length < 3) return result;
Arrays.sort(nums);

int len = nums.length;
for(int i = 0; i < len; i++) {
    if(i > 0 && nums[i] == nums[i - 1]) continue;        // Skip same results
    int target = 0 - nums[i];
    int j = i + 1, k = len - 1;
    while(j < k) {
        if(nums[j] + nums[k] == target) {
            result.add(Arrays.asList(nums[i], nums[j], nums[k]));
            while(j < k && nums[j] == nums[j + 1]) j++;  // Skip same results
            while(j < k && nums[k] == nums[k - 1]) k--;  // Skip same results
            j++; k--;
        } else if(nums[j] + nums[k] < target) {
            j++;
        } else {
            k--;
        }
    }
}
return result;
}