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)

runtime:

Solution:

1. sort input number

2. fix the left-end number, go and find the rest two numbers which meet the requirement.

3. there some tips to accelerate the algorithm: such as: "

while( num1[pl] == num1[pl+1] ) { pl++; }

"

source code:

vector<vector<int> > threeSum(vector<int> &num) {
	vector<int> num1(num);
	vector<vector<int> > triplets;
	sort(num1.begin(), num1.end());
	if(num1.size() < 3 || num1[0] > 0 || num1[num1.size()-1] < 0)
		return triplets;

	int base = 0; // fix left-end number in every loop
	//note: left-end number should not be bigger than zero
	while(num1[base] <= 0) { 		
		int pl = base+1;
		int ph = num1.size()-1;
		while( pl < ph ) {
			int thrsum = num1[pl] + num1[ph] + num1[base];
			if( thrsum < 0 ) { pl++; }
			else if (thrsum >0 ) { ph--; }
			else if( thrsum == 0 ) {
				vector<int> tmp;
				tmp.push_back(num1[base]); 
				tmp.push_back(num1[pl]); 
				tmp.push_back(num1[ph]);
				// to avoid duplicate cases
				if( triplets.size() > 0 && 
					(triplets[triplets.size()-1] == tmp) )
				{ pl++; continue; }
				triplets.push_back(tmp);
				// avoid some similar operations
				while( num1[pl] == num1[pl+1] ) { pl++; }
				pl++;
			}
		}
		base++;
		while(num1[base] == num1[base-1]) { base++; }
	}
	return triplets;
}