两数之和
- leetcode关于两数之和的题目有一个系列,两数之和–>两数之和(有序数列)
–>三数之和–>四数之和,这些系列题目看着一个比一个复杂,但是都是基于一个结题思路-双指针。
两数之和-无序
- 题目描述:
-
给定一个整数数组 nums 和一个整数目标值 target,请你在该数组中找出 和为目标值 target 的那 两个 整数,并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是,数组中同一个元素在答案里不能重复出现。
你可以按任意顺序返回答案。 - 示例:
-
输入:nums = [2,7,11,15], target = 9
输出:[0,1]
解释:因为 nums[0] + nums[1] == 9 ,返回 [0, 1] 。 - 解析:由于这是一个无序数列,而且是返回和为target对应数组元素的下标,因此,这里不用双指针,用一个哈希记录已经遍历过的值和索引,用一次遍历就可以完成算法,时间复杂度为O(n),因为新建了一个哈希表来存储遍历元素和对应索引,所以空间复杂度为O(n)
- 代码如下:
class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
"""
在一个数组中找出和为target的两个数对应的数组下标
>>>self.twoSum([2,3,4], 7)
>>>[1,2]
"""
#记录数字对应的索引
dn = {}
for i, x in enumerate(nums):
if target-x in dn.keys():
return [dn[target-x], i]
dn[x] = i
return []
两数之和-有序
- 题目描述:
-
给定一个已按照 非递减顺序排列 的整数数组 numbers ,请你从数组中找出两个数满足相加之和等于目标数 target 。
函数应该以长度为 2 的整数数组的形式返回这两个数的下标值。numbers 的下标 从 1 开始计数 ,所以答案数组应当满足 1 <= answer[0] < answer[1] <= numbers.length 。
你可以假设每个输入 只对应唯一的答案 ,而且你 不可以 重复使用相同的元素。 - 示例:
-
输入:输入:numbers = [2,7,11,15], target = 9
输出:[1,2]
解释:2 与 7 之和等于目标数 9 。因此 index1 = 1, index2 = 2 。 - 解析:由于这是一个有序数列,返回和为target对应数组元素的下标,因此,这里可以使用双指针从数组头尾同时相向移动,指针最多移动n-2次,因此时间复杂度为O(n),变量都是数值常量,因此空间复杂度为O(1)
- 代码如下:
class Solution:
def twoSum(self, numbers: List[int], target: int) -> List[int]:
"""
非递减数列中返回和为target的两个数的索引下标
>>>self.twoSum([2,7,11,15], 9)
>>>[1, 2]
"""
start, end = 0, len(numbers)-1
while start < end:
if numbers[start] + numbers[end] == target:
return [start+1, end+1]
elif numbers[start] + numbers[end] > target:
end -= 1
else:
start += 1
return []
三数之和
- 题目描述:
-
给你一个包含 n 个整数的数组 nums,判断 nums 中是否存在三个元素 a,b,c ,使得 a + b + c = 0 ?请你找出所有和为 0 且不重复的三元组。
注意:答案中不可以包含重复的三元组。 - 示例:
-
输入:输入:nums = [-1,0,1,2,-1,-4]
输出:[[-1,-1,2],[-1,0,1]] - 解析:这是一个无序数组,但是返回的数组元素的值,因此,我们可以先对原数组进行排序,同样使用使用双指针从数组头尾同时相向移动,但是不同于有序数组的二数之和,这里需要先固定一个数,然后从头尾相向移动,比如数组长度为n,固定排序后数组的第k个数,设start=0, end=n-1,双指针向nums[k]相向移动,循环条件是start<k,end>k,那么满足三数之和的条件时候,返回[nums[start], nums[k],nums[end]]。算法需要对每一个元素进行遍历,然后在有序数组上进行二数之和的流程,因此时间复杂度n*(n-3),为O(n2),变量都是数值常量,因此空间复杂度为O(1)
- 代码如下:
class Solution:
def threeSum(self, nums: List[int]) -> List[List[int]]:
"""
给定一个数组,找出所有三个元素和为0的组合
>>>self.threeSum(nums_temp[start] + nums_temp[end] == target:)
>>>[[-1,-1,2],[-1,0,1]]
"""
res = []
if len(nums) < 3:
return []
nums.sort()
for i in range(len(nums)):
if i>1 and nums[i]==nums[i-2]:
continue
start, end = 0 , len(nums)-1
target = -nums[i]
while start<i and end>i:
if nums[start] + nums[end] == target:
if [nums[start], nums[i], nums[end]] not in res:
res.append([nums[start], nums[i], nums[end]])
start += 1
end -= 1
elif nums[start] + nums[end] > target:
end -= 1
else:
start += 1
return res
四数之和
- 题目描述:
-
给你一个由 n 个整数组成的数组 nums ,和一个目标值 target 。请你找出并返回满足下述全部条件且不重复的四元组 [nums[a], nums[b], nums[c], nums[d]] (若两个四元组元素一一对应,则认为两个四元组重复):
0 <= a, b, c, d < n
a、b、c 和 d 互不相同
nums[a] + nums[b] + nums[c] + nums[d] == target
你可以按 任意顺序 返回答案 。 - 示例:
-
输入:输入:nums = [1,0,-1,0,-2,2], target = 0
输出:[[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]] - 解析:这是一个无序数组,但是返回的数组元素的值,因此,我们可以先对原数组进行排序,算法原理和三数之和一样,本质都是基于二数之和的双指针来进行优化。到四数之和就是固定一个数nums[k],然后调用三数之和的方法(传入的数组不含nums[k])寻找三数之和为target-nums[k]的三数组合,五数之和、六数之和都可以此类推,每多一个数,算法时间复杂度要嵌套一层,因此时间复杂度n*(n-1)*(n-3),为O(n3),算法过程中产生了一个长度为n-1的数组切片,因此空间复杂度为O(n)
- 代码如下:
class Solution:
def fourSum(self, nums: List[int], target: int) -> List[List[int]]:
"""
给定一个数组,找出所有四个元素和为target的组合
>>>self.fourSum([1,0,-1,0,-2,2], 0)
>>>[[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
"""
res = []
nums.sort()
for i in range(len(nums)):
temp = self.threeSum(nums[:i]+nums[i+1:], target-nums[i])
if temp:
for three in temp:
three.append(nums[i])
three.sort()
if three not in res:
res.append(three)
return res
def threeSum(self, nums, target):
"""
给定一个数组,找出所有三个元素和为target的组合
>>>self.threeSum([-1,0,1,2,-1,-4], 0)
>>>[[-1,-1,2],[-1,0,1]]
"""
res = []
nums.sort()
for i in range(len(nums)):
if i>1 and nums[i]==nums[i-2]:
continue
start, end = 0 , len(nums)-1
target_1 = target-nums[i]
while start<i and end>i:
if nums[start] + nums[end] == target_1:
if [nums[start], nums[i], nums[end]] not in res:
res.append([nums[start], nums[i], nums[end]])
start += 1
end -= 1
elif nums[start] + nums[end] > target_1:
end -= 1
else:
start += 1
return res