[LeetCode] 3Sum

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:
• Elements in a triplet (a, b, c) must be in non-descending order. (ie, a  b  c)

• 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)

 

分析：先排序，然后取出一个数后，在余下的数中找其他两个，即2sum，另外注意，由于题目中指定了unique，不能有重复，所以在b++，c--，a++时都要对重复情况做处理。

 

PS；其实直接使用系统的sort就行，我这里实现了一个mergeSort，算是练手吧。。 

PSPS: 在对mergeSort说两句，在mergeSort中，有条件判断 if(low < high)， 但low>= high时，就返回了，即一个元素时就什么也不做，然后执行merge()函数，就自定向上完成了排序。。

 

class Solution {
    
    void merge(int* array, int low, int mid, int high)
    {
        int *newArray = (int*)malloc(sizeof(int)* (high-low +1));
        
        int i = low, j = mid+1, k = 0;
        
        while(i <= mid && j <= high)
        {
            if(array[i] < array[j])
            {
                newArray[k++] = array[i++];
            }
            else
                newArray[k++] = array[j++];
        }
        
        while(i <= mid)
            newArray[k++] = array[i++];
            
        while(j<=high)
            newArray[k++] = array[j++];
            
        for(i = low; i<= high; i++)
            array[i] = newArray[i];
            
        free(newArray);
    }
    
    void mergeSort(int* array, int low, int high)
    {
        if(low < high)
        {
            int mid = (low + high)/2;
        
            mergeSort(array, low, mid);
            mergeSort(array, mid+1, high);
            merge(array, low, mid, high);
        }  
    }
    
public:
    vector<vector<int> > threeSum(vector<int> &array) {
        
        int n = array.size();
        
        sort(array.begin(), array.end());
        
         vector<vector<int>> result;
        
        //mergeSort(array, 0, n-1);
        
        int a, b , c;
        
        for(a = 0; a < n-2; )
        {
            b = a +1;
            c = n-1;
            while(b<c)
            {
                if(array[a] + array[b]+ array[c] == 0)
                {
                    vector<int> temp;
                    temp.push_back(array[a]);
                    temp.push_back(array[b]);
                    temp.push_back(array[c]);
                    result.push_back(temp);
                    // this is very important b++ and c--
                    
                    //skip the dupliate ones
                    do {b++;} while(array[b] == array[b-1] && (b < n-1));
                    do {c--;} while(array[c] == array[c+1] && (c > a));
                }
                else if(array[a] + array[b]+ array[c] < 0)
                    b++;
                else
                    c--;
            }   
            a++;
            // skip the duplicate ones
            while (array[a] == array[a-1] && a < n-2) a++;
        }
        

        
        return result;
    }
};