leetcode15

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        Arrays.sort(nums);
        List<List<Integer>> ls = new LinkedList<>();
 
        for (int i = 0; i < nums.length - 2; i++) {
            if (i == 0 || (i > 0 && nums[i] != nums[i - 1])) {  // 跳过可能重复的答案
 
                int l = i + 1, r = nums.length - 1, sum = 0 - nums[i];
                while (l < r) {
                    if (nums[l] + nums[r] == sum) {
                        ls.add(Arrays.asList(nums[i], nums[l], nums[r]));
                        while (l < r && nums[l] == nums[l + 1]) l++;
                        while (l < r && nums[r] == nums[r - 1]) r--;
                        l++;
                        r--;
                    } else if (nums[l] + nums[r] < sum) {
                        while (l < r && nums[l] == nums[l + 1]) l++;   // 跳过重复值
                        l++;
                    } else {
                        while (l < r && nums[r] == nums[r - 1]) r--;
                        r--;
                    }
                }
            }
        }
        return ls;
    }
}

使用python实现：

class Solution:
    def threeSum(self, nums: 'List[int]') -> 'List[List[int]]':
        nums = sorted(nums)
        res = []
        n = len(nums)
        for i in range(n-2):
            if i == 0 or nums[i] != nums[i-1]:
                l,r,sums = i + 1,n-1,0-nums[i]
                while l < r:
                    if nums[l] + nums[r] == sums:
                        res.append([nums[i],nums[l],nums[r]])
                        while l < r and nums[l] == nums[l+1]:
                            l += 1
                        while l < r and nums[r] == nums[r-1]:
                            r -= 1
                        l += 1
                        r -= 1
                    elif nums[l] + nums[r] < sums:
                        while l < r and nums[l] == nums[l+1]:
                            l += 1
                        l += 1
                    else:
                        while l < r and nums[r] == nums[r-1]:
                            r -= 1
                        r -= 1
        return res

下面补充另一种思路，使用python实现，是根据leetcode167 twonum II的思路来做的，效率比上面的方法要高一些，代码如下：

class Solution:
    def towSum(self,numbers,target):
        i = 0
        j = len(numbers) - 1

        ary = list()
        while i < j:
            sums = numbers[i] + numbers[j]
            #print(str(i)+','+str(j)+'->'+str(sums))
            if sums == target:
                #return numbers[i],numbers[j]
                ary.append([numbers[i],numbers[j]])
                while i < j and numbers[i]==numbers[i+1]:
                    i+=1
                i+=1
            elif sums < target:
                i+=1
            else:
                j-=1
        return ary

    def threeSum(self, nums: 'List[int]') -> 'List[List[int]]':
        result = list()
        
        sortedlist = sorted(nums)

        zlist = list(filter(lambda x:x==0,sortedlist))
        if len(zlist) >= 3:
            result.append([0,0,0])

        nlist = list(filter(lambda x:x<0,sortedlist))
        nset = set(nlist)

        plist = list(filter(lambda x:x>=0,sortedlist))
        pset = set(plist)
        for target in nset:
            aa = self.towSum(plist,target*-1)
            for a in aa:
                a1 = a[0]
                a2 = a[1]
                clist = [a1,a2,target]
                result.append(clist)
                    

        for target in pset:
            aa = self.towSum(nlist,target*-1)
            for a in aa:
                a1 = a[0]
                a2 = a[1]
                clist = [a1,a2,target]
                result.append(clist)
        
        return result