LeetCode-算法编程——15. 三数之和

原题目：

给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请

你返回所有和为 0 且不重复的三元组。

注意：答案中不可以包含重复的三元组。

提示：

• 3 <= nums.length <= 3000
• -105 <= nums[i] <= 105

示例 1：

输入：nums = [-1,0,1,2,-1,-4]
输出：[[-1,-1,2],[-1,0,1]]
解释：
nums[0] + nums[1] + nums[2] = (-1) + 0 + 1 = 0 。
nums[1] + nums[2] + nums[4] = 0 + 1 + (-1) = 0 。
nums[0] + nums[3] + nums[4] = (-1) + 2 + (-1) = 0 。
不同的三元组是 [-1,0,1] 和 [-1,-1,2] 。
注意，输出的顺序和三元组的顺序并不重要。

示例 2：

输入：nums = [0,1,1]
输出：[]
解释：唯一可能的三元组和不为 0 。

示例 3：

输入：nums = [0,0,0]
输出：[[0,0,0]]
解释：唯一可能的三元组和为 0 。

分析：

        直接三重循环判断太慢了，还要注意重复的数据，换种思路。

        对于数组长度为3或小于3的可直接返回结果，当然给定的数据中数组最小长度为3。

        使用内部排序使数组变有序会更容易解答，排序后，根据题意，若第一个大于0，最后一个小于0，那么整个数组是没有结果的，直接返回空；

        对于其它数据，先确定第一个数，然后在后面的范围中用左右双指针确定剩下两个数，因为已经排序，所以能更快的找到；

        同时可以增加一些方法来优化时间，比如第一个数大于0时，后面的结果均不满足，直接跳出循环；当第一个数前面已经计算过，就不再重复计算，左右指针也可进行判断，相同的值不再计算，避免出现重复的值。

        也可把三数之和为0转化为两数之和。

代码：

Python3版本

class Solution:
    def threeSum(self, nums: List[int]) -> List[List[int]]:
        # 计算保存当前数组长度
        length = len(nums)
        # 长度等于3和小于3的直接返回结果
        if length == 3:
            if nums[0] + nums[1] + nums[2] == 0:
                return [[nums[0], nums[1], nums[2]]]
            else:
                return []
        elif length < 3:
            return []
        # 内部排序，使数据有序，更快查找
        nums.sort()
        # 三数之和为0，必然出现排序后第一个数大于0和最后一个数小于0时没有结果，直接返回空
        if nums[0] > 0 or nums[length - 1] < 0:
            return []
        # 存储结果的数组
        res = []
        # 三个数中的第一个，循环范围为0到length-2
        for i in range(0, length - 2):
            # 排序后，如果第一个数就大于0，那么后面不会再出现三个数相加为0，所以直接跳出返回结果
            if nums[i] > 0:
                break
            # 避免结果重复，第一个数如果和前一个数相同，就不再计算
            if i > 0 and nums[i] == nums[i - 1]:
                continue
            # 对于剩下的两个数，定义左右指针查找
            left, right = i + 1, length - 1
            #索引位置不重复，所以小于就可以
            while left < right:
                #这是在当前要找的目标值
                target = nums[i] + nums[left] + nums[right]
                #数组已经有序，如果目标值大于0，右指针减小；目标值小于0，左指针增加；等于0时命中
                if target > 0:
                    right = right - 1
                elif target < 0:
                    left = left + 1
                else:
                    #等于0时命中，保存结果
                    res.append([nums[i], nums[left], nums[right]])
                    #防止左边后面的值与当前值一样，跳过计算
                    while left < right and nums[left] == nums[left + 1]:
                        left = left + 1
                    left = left + 1
                    # 防止右边前面的值与当前值一样，跳过计算
                    while left < right and nums[right] == nums[right - 1]:
                        right = right - 1
                    right = right - 1
        return res