3.9三数之和（LC15_M）

给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请你返回所有和为 0 且不重复的三元组。

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

示例 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 。

算法：

双指针法：

1. 排序数组：

• 首先对输入的数组进行排序。排序可以让我们更方便地使用双指针技术，并且有助于去重操作。

2. 三层循环结构：

• 第一层循环（first 指针）：遍历数组中的每一个元素，将其作为当前三元组的第一个元素。由于数组是有序的，接下来的步骤可以利用有序性来高效查找另外两个元素。
• 双指针查找（second 和 third 指针）：在固定了第一个元素后，使用双指针法在剩下的部分中查找两个元素，使得这三个元素的和为零。second 从左向右移动，third 从右向左移动。

3. 跳过重复元素：

• 外层去重：在选择第一个元素时（first），如果这个元素与前一个元素相同，则跳过它，避免重复的计算。
• 内层去重：在找到一个符合条件的三元组后，移动 second 和 third 指针，跳过与当前元素相同的其他元素，防止添加重复的三元组。

4. 双指针查找的逻辑：（second从小变大，third从大变小）

• 初始条件：second 指针从 first 的下一个位置开始，third 指针从数组末尾开始。
• 检查和：
  • 如果 nums[second] + nums[third] 等于 -nums[first]，则找到一个有效的三元组，将其加入结果中，并移动两个指针以跳过重复元素。
  • 如果 nums[second] + nums[third] 小于 -nums[first]，则需要增加 second 指针，以增大总和。
  • 如果 nums[second] + nums[third] 大于 -nums[first]，则需要减小 third 指针，以减小总和。

正确代码：

class Solution(object):
    def threeSum(self, nums):
        """
        :type nums: List[int]
        :rtype: List[List[int]]
        """
        #去重：先排序
        #nums[first] + x = 0
        #nums[second] + nums[third] = - nums[first] = x
        #second 一定小于 third， second从小变大， third从大变小（双指针）
        #写代码的时候一定要牢记：first < second <third
        nums.sort()#从小到大排序
        res = list()
       
        for first in range(0, len(nums)):      
            x = 0-nums[first]          
            #跳过重复数字：
            if first>0 and nums[first] == nums[first-1]:
                continue
            #second应该在first右边
            second = first + 1
            third = len(nums)-1
            while third > second:

                if nums[second] + nums [third] == x:
                    res.append([nums[first],nums[second],nums[third]])
                    second += 1
                    third -= 1
                    #因为second和third已经更新了，所以内部的while循环要依然要写while second < third
                    while second < third and nums[second] == nums[second-1]:
                        second += 1
                    while second < third and nums[third] == nums[third+1]:
                        third -= 1
                        
                elif nums[second] + nums [third] > x:
                    third -= 1
                else:
                    second +=1
                
        return res
            

时间空间复杂度：

该算法的时间复杂度是 O(n^2)，其中 n 是数组的长度。

具体分析：

1. 排序：对数组进行排序的时间复杂度是 O(n log n)。
2. 双指针遍历：主循环遍历数组的时间复杂度为 O(n)，对于每个元素，都有一个内部的双指针遍历，时间复杂度为 O(n)。因此，双指针遍历的整体时间复杂度是 O(n * n) = O(n^2)。

由于 O(n^2) 在时间复杂度上是主导因素，因此总体时间复杂度是 O(n^2)。

空间复杂度

该算法的空间复杂度是 O(1)，如果不考虑返回结果所占用的空间。