# Leetcode-双指针系列1

mhxin

## 15. 三数之和

[
[-1, 0, 1],
[-1, -1, 2]
]

• 排序
• 固定第一个数, 用p0表示. 使用另外两个指针p1, p2, 分别指向第一个数后面的元素和最后一个元素.
• 当p0, p1, p2指向的元素之和大于0时, p2左移, 小于0时, p1右移, 否则, 将当前的3个元素添加到结果中. 当p1 = p2时, 结束循环. 回到第2步.

``````def ThreeSum(nums):
if not sums or len(sums) < 3:
return []

nums.sort()
n = len(nums)
res = []
for i in range(n-2):
p1 = i + 1
p2 = n - 1

while p1 < p2:

if nums[p1] + nums[p2] < -nums[i]:
p1 += 1
elif nums[p1] + nums[p2] > -nums[i]:
p2 -= 1
else:
res.append([nums[i], nums[p1], nums[p2]])
p1 += 1
p2 -= 1
return res``````

[[-1,-1,2],[-1,0,1],[-1,0,1]]的结果, 因此我们需要跳过第二个及以后的重复元素.

``````def ThreeSum(nums):
if not sums or len(sums) < 3:
return []

nums.sort()
n = len(nums)
res = []
"""
如果第一个元素就大于0或者最后一个元素还小于0直接返回.
"""
if nums[0] > 0 or nums[-1] < 0:
return res

for i in range(n-2):
p1 = i + 1
p2 = n - 1

"""
去重
"""
if i > 0 and nums[i] == nums[i-1]:
continue

while p1 < p2:

if nums[p1] + nums[p2] < -nums[i]:
p1 += 1
elif nums[p1] + nums[p2] > -nums[i]:
p2 -= 1
else:
res.append([nums[i], nums[p1], nums[p2]])
"""
去重
"""
while p1 < p2 and nums[p1] == nums[p1 + 1]:
p1 += 1
while p1 < p2 and nums[p2] == nums[p2 - 1]:
p2 -= 1
p1 += 1
p2 -= 1

return res``````

## 16. 最接近的三数之和

``````def threeSumClosest(nums, target):
if not nums or len(nums) < 3:
return []

n = len(nums)

# 排序
nums.sort()
res = []
nearest_sum = sum(nums[:3])
if nums[0] >= target:
return sum(nums[:3])

if nums[-1] <= target:
return sum(nums[-3:])

for i in range(n-2):
p1 = i + 1
p2 = n - 1

while p1 < p2:
temp = nums[i] + nums[p1] + nus[p2]

if abs(temp - target) < abs(nearest_sum - target):
nearest_sum = temp

if temp < target:
p1 += 1
elif temp > target:
p2 -= 1
else:
return target

return nearest_sum
``````

## 18. 四数之和

[
[-1, 0, 0, 1],
[-2, -1, 1, 2],
[-2, 0, 0, 2]
]

``````
def fourSum(nums, target):
if not nums or len(nums) < 4:
return []

nums.sort()
n = len(nums)
res = []
for i in range(n-3):
# 去重
if i > 0 and nums[i] == nums[i-1]:
continue
for j in range(i, n-2):
p1 = j + 1
p2 = n - 1

# 去重
if j > i and nums[j] == nums[j-1]:
continue

while p1 < p2:
temp = nums[i] + nums[j] + nums[p1] + nums[p2]
if temp < target:
p1 += 1
elif temp > target:
p2 -= 1

else:
res.append([nums[i], nums[j], nums[p1], nums[p2]])
# 去重
while p1 < p2 and nums[p1] == nums[p1+1]:
p1 += 1

while p1 < p2 and nums[p2] == nums[p2-1]:
p2 -= 1

p1 += 1
p2 -= 1
return res
``````

## 26. 删除排序数组中的重复项

• 设置两个指针p1, p2, 都初始化为0, 同时指向数组中第一个元素.
• 当p1位置的元素和p2位置的元素相等时, p2右移, 否则p1右移, 然后交换两个位置的值, p2右移.
• 重复执行第2步.
``````def removeDuplicates(nums):
if not nums:
return 0
if len(nums) < 2:
return 1

# 同时指向第一个元素
p1 = p2 = 0
n = len(nums)
while p2 < n:
# 如果不相等, p1右移后， 交换两指针位置的值
if nums[p2] != nums[p1]:
p1 += 1
nums[p2], nums[p1] = nums[p1], nums[p2]
p2 += 1

return p1 + 1``````

## 27. 移除元素

``````给定 nums = [3,2,2,3], val = 3,

``````给定 nums = [0,1,2,2,3,0,4,2], val = 2,

• 设置两个指针, p1, p2, 同时初始化为0
• 当p2元素不等于val时, 交换p1, p2位置元素. p1右移, p2右移
• 当p2元素等于val时, p2右移
• 回到第2步
``````def removeElement(nums, val):
if not nums:
return 0
if len(nums) == 1:
return int(nums[0] != val)

n = len(nums)
p1 = p2 = 0

while p2 < n:
if nums[p2] != val:
nums[p1], nums[p2] = nums[p2], nums[p1]
p1 += 1
p2 += 1

return p1``````

• 设定两个指针p1,p2, 分别指向0和n-1.
• 如果p2位置元素等于val, 将其左移, 直至p2位置元素不等于val或者p2小于0.
• 当p1位置元素等于val时, 交换p1, p2位置的值, p1右移, p2左移.
• 当p2位置不等于val时, p1右移.
• 重复2-4步骤, 直至p1大于p2
``````def removeElement(nums, val):
if not nums:
return 0
if len(nums) == 1:
return int(nums[0] != val)

n = len(nums)
p1 = 0
p2 = n - 1

# 这里需要有等号
while p1 <= p2:
while p2 > p1 and nums[p2] == val:
p2 -= 1
if nums[p1] == val:
nums[p2], nums[p1] = nums[p1], nums[p2]
p2 -= 1

p1 += 1

return p2 + 1``````

## 75. 颜色分类

• 一个直观的解决方案是使用计数排序的两趟扫描算法。

首先，迭代计算出0、1 和 2 元素的个数，然后按照0、1、2的排序，重写当前数组。

• 你能想出一个仅使用常数空间的一趟扫描算法吗？

• 设置3个指针cur, p1, p2, 分别指向当前位置, 0的右边界和2的左边界, 初始化为0, 0, n-1.
• 当cur位置元素为0, 交换p1, cur位置的元素, p1, cur同时右移
• 当cur位置元素为2时, 交换p2, cur位置的元素, p2左移
• 当cur位置元素为1时, cur右移.
• 循环执行以上步骤, 直至cur 等于p2
``````def sortColors(nums):
if not nums or len(nums) < 2:
return

cur = p1 = 0
p2 = len(nums) - 1

while cur < p2:
if nums[cur] == 0:
nums[cur], nums[p1] = nums[p1], nums[cur]
p1 += 1
cur += 1
# Note: 当cur位置的值等于2时, cur不需要右移, 因为交换之后并不能保证cur位置的值不等于2.
elif nums[cur] == 2:
nums[cur], nums[p2] = nums[p2], nums[cur]
p2 -= 1
else:
cur += 1
``````

## 88. 合并两个有序数组

• 初始化 nums1 和 nums2 的元素数量分别为 m 和 n 。
• 你可以假设 nums1 有足够的空间（空间大小大于或等于 m + n）来保存 nums2 中的元素。

nums1 = [1,2,3,0,0,0], m = 3
nums2 = [2,5,6], n = 3

• 设置两个指针p1, p2, 分别指向nums1的m-1和nums2的n-1位置.
• 当p1位置元素大于p2位置元素时, 将nums1的m+n-1位置的值者只为p1位置的值, p1左移, 否则将nums1的m+n-1位置的值者只为p2位置的值, p2左移.
• 回到上一步, 直至p1<0或者p2<0
``````
def merge(nums1, m, nums2, n):
if not nums2:
return nums1

i = m - 1
j = n - 1

while i >= 0 and j >= 0:
if nums1[i] > nums[j]:
nums1[i+j+1] = nums1[i]
i -= 1
else:
nums1[i+j+1] = nums2[j]
j -= 1
if j >= 0:
nums1[:j] = nums2[:j]
return nums1``````

## 21. 合并两个有序链表

``````
def mergeTwoLists(l1, l2):

p1 = l1
p2 = l2

# 初始化为一个临时节点
p0 = new_ln = ListNode(-1)
while p1 and p2:
if p1.val < p2.val:
p0.next = p1
p1 = p1.next
else:
p0.next = p2
p2 = p2.next
p0 = p0.next
if p1:
p0.next = p1
if p2:
p0.next = p2

return new_ln.next``````

## 剑指 Offer 21. 调整数组顺序使奇数位于偶数前面

• 使用两个指针p1, p2, 分别初始化为0, n-1
• 当p1位置元素为奇数时, p1右移;
• 当p2位置元素为偶数时, p2左移
• 否则交换p1, p2位置元素.
``````def exchange(nums):
if not nums or len(nums) < 2:
return nums

n = len(nums)

p1 = 0
p2 = n - 1
while p1 < p2:
if nums[p1] % 2:
p1 += 1
elif not nums[p2] % 2:
p2 -= 1
else:
nums[p1], nums[p2] = nums[p2], nums[p1]

return nums``````

``````def exchange(self, nums: List[int]) -> List[int]:
if not nums or len(nums) < 2:
return nums

n = len(nums)
p2 = p1 = 0
while p2 < n:
if nums[p2] %2:
nums[p1], nums[p2] = nums[p2], nums[p1]
p1 += 1
p2 += 1
return nums``````

## 总结

• 同时初始化为0或者链表头节点
• 当前元素不满足条件时, 交换快慢指针指向的值; 慢指针右移, 快指针右移
• 否则, 快指针右移
• 重复2-3步骤

82 声望
12 粉丝
0 条评论