Leetcode刷题(17) 双指针系列
快慢指针系列(泛指)
参考labuladong的如何去除有序数组的重复元素
26. 删除排序数组中的重复项
# 双指针(快慢指针)
class Solution(object):
def removeDuplicates(self, nums):
"""
:type nums: List[int]
:rtype: int
"""
n = len(nums)
if n == 0:
return 0
slow = 0
fast = 1
while(fast < n):
# 如果当前的nums[fast]和当前的nums[slow]不同
# 便后移slow, 将nums[fast]赋值给后移之后的nums[fast]
if nums[fast] != nums[slow]:
slow += 1
nums[slow] = nums[fast]
# 每次都要后移一次fast
fast += 1
return slow + 183. 删除排序链表中的重复元素
# Definition for singly-linked list.
# class ListNode(object):
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution(object):
def deleteDuplicates(self, head):
"""
:type head: ListNode
:rtype: ListNode
"""
if not head:
return None
slow = head
fast = head
while fast!=None:
# 当遇到slow.val的值和fast.val的值不相同的时候
# 就可以直接跳过中间相同val的节点连接到这个fast.val上
# 然后更新slow为fast指向的节点
if slow.val != fast.val:
# 跳过当前的fast
slow.next = fast
slow = fast
# fast一直在向前移动
fast = fast.next
# 注意这里要把slow后面多余的节点给截断
slow.next = None
return head
283. 移动零
双指针之左右指针
参考labuladong的如何高效解决接雨水问题
class Solution(object):
def moveZeroes(self, nums):
"""
:type nums: List[int]
:rtype: None Do not return anything, modify nums in-place instead.
"""
n = len(nums)
if n == 0:
return []
slow = 0
for fast in range(n):
# 如果i的位置不是0的话就把i上的元素填到j的位置上
if nums[fast] != 0:
nums[slow] = nums[fast]
# 如果不是自己换自己的话, 就要将0换到后面保持0的个数
if slow != fast:
nums[fast] = 0
# 腾出下一个放非0数字的位置
slow += 111. 盛最多水的容器
相向而行的左右指针
class Solution(object):
def maxArea(self, height):
"""
:type height: List[int]
:rtype: int
"""
# 双指针, 左右指针相向而行
n = len(height)
if n == 0:
return 0
left = 0
right = n - 1
ares = 0
while left < right:
if height[left] < height[right]:
ares = max(ares, (right - left) * height[left])
left += 1
else:
ares = max(ares, (right - left) * height[right])
right -= 1
return aresclass Solution(object):
def maxArea(self, height):
"""
:type height: List[int]
:rtype: int
"""
n = len(height)
left = 0
right = n - 1
max_area = 0
while(left < right):
# 得到面积
max_area = max(min(height[right], height[left]) * (right-left), max_area)
# 小的height向大的height的方向移动
if height[left] > height[right]:
right -= 1
else:
left += 1
return max_area
42. 接雨水
class Solution(object):
def trap(self, height):
"""
:type height: List[int]
:rtype: int
"""
n = len(height)
if n == 0:
return 0
l = 0
l_max = height[l]
r = n -1
r_max = height[r]
ans = 0
while l <= r:
l_max = max(l_max, height[l])
r_max = max(r_max, height[r])
if l_max < r_max:
ans += l_max - height[l]
l += 1
else:
ans += r_max - height[r]
r -= 1
return ans15. 三数之和
先排序，再用双指针，毕竟要的只是值不是索引
参考labuladong的一个函数秒杀N桑(Sum)问题
class Solution(object):
def threeSum(self, nums):
"""
:type nums: List[int]
:rtype: List[List[int]]
"""
nums = sorted(nums)
n = len(nums)
ans = []
def twoSum(start, target):
l = start
r = n-1
res = []
while(l < r):
sum_ = nums[l] + nums[r]
left = nums[l]
right = nums[r]
if sum_ < target:
# while(l < r and left==nums[l]):
l += 1
elif sum_ > target:
# while(l < r and right==nums[r]):
r -= 1
elif sum_ == target:
res.append([left, right])
while(l < r and left==nums[l]):
l += 1
while(l < r and right==nums[r]):
r -= 1
return res
i = 0
while i < n:
cur_i = i
target = 0 - nums[cur_i]
res = twoSum(cur_i + 1, target)
for re in res:
re.append(nums[cur_i])
ans.append(re)
i += 1
# 跳过相等的元素,避免重复
while(i < n and nums[cur_i]==nums[i]):
i += 1
return ans704. 二分查找
参考labuladong的二分查找详解
左右指针
class Solution(object):
def search(self, nums, target):
"""
:type nums: List[int]
:type target: int
:rtype: int
"""
left = 0
right = len(nums)
while(left < right):
# 防止right + left太大导致溢出
mid = left + (right - left) / 2
if (nums[mid] == target):
return mid
elif(nums[mid] > target):
right = mid
elif(nums[mid] < target):
left = mid + 1
return -134. 在排序数组中查找元素的第一个和最后一个位置
左右指针
# 寻找边界一般用左闭右开的区间来搜索
class Solution(object):
def searchRange(self, nums, target):
"""
:type nums: List[int]
:type target: int
:rtype: List[int]
"""
def findleft():
l = 0
r = len(nums)
while(l < r): # 终止条件 l == r
mid = l + (r - l) / 2
if nums[mid] == target:
r = mid
elif nums[mid] > target:
r = mid
elif nums[mid] < target: # l跳过的一定是不大于target的数字, 终止的时候一般是在大于等于target的位置(如果有target的话就会在等于的位置)
l = mid + 1
# 处理越界
if l == len(nums):
return -1
else:
return l if nums[l] == target else -1
def findright():
l = 0
r = len(nums)
while(l < r): # 终止条件 l == r
mid = l + (r - l) / 2
# l只有加的操作, 所以在终止的时候l一定是跳过了一个等于(小于)target的,如果有等于的就不会轮到小于的
# 轮不到等于的l就会一直右移直到越界(len(nums))
if nums[mid] == target:
l = mid + 1
elif nums[mid] > target:
r = mid
elif nums[mid] < target:
l = mid + 1
# 处理越界
# l - 1 = -1
if l == 0:
return -1
else:
return l-1 if nums[l-1] == target else -1
l = findleft()
r = findright()
return [l, r]我想下面这两题也能算针对两个不同字符串的双指针吧:
415. 字符串相加
class Solution:
def addStrings(self, num1, num2):
res = ""
# carry 记录上一次计算的进位
i, j, carry = len(num1) - 1, len(num2) - 1, 0
# 从低位遍历, 反着遍历
while i >= 0 or j >= 0:
n1 = int(num1[i]) if i >= 0 else 0
n2 = int(num2[j]) if j >= 0 else 0
tmp = n1 + n2 + carry # 上一次计算的进位加到这里
carry = tmp / 10
res = str(tmp % 10) + res
i, j = i - 1, j - 1
return "1" + res if carry else res43. 字符串相乘
class Solution(object):
def multiply(self, num1, num2):
"""
:type num1: str
:type num2: str
:rtype: str
"""
n1 = len(num1)
n2 = len(num2)
n = n1 + n2
res = [0] * n
for i in range(n1 - 1, -1, -1):
for j in range(n2 - 1, -1, -1):
p1 = i + j
p2 = i + j + 1
# 其实下面这段我想了很久才想通, 我觉得p1和p2反了,
# 之后才想起来, p1才是高位, 而且在p1上不可能再有进位
curtotal = int(num1[i]) * int(num2[j]) + res[p2]
res[p2] = curtotal % 10
res[p1] += curtotal / 10
count = 0
while(count < n and res[count] == 0):
count += 1
if count >= n:
return "0"
else:
res = res[count:]
res = list(map(str, res))
return ''.join(res)
剑指 Offer 52. 两个链表的第一个公共节点
# Definition for singly-linked list.
# class ListNode(object):
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution(object):
def getIntersectionNode(self, headA, headB):
"""
:type head1, head1: ListNode
:rtype: ListNode
"""
a = headA
b = headB
# 除非两个都是None否则继续遍历
while a or b:
# 最后一段路两个人一定是一起走的
if a == b:
return a
else:
if a == None:
a = headB
else:
a = a.next
if b == None:
b = headA
else:
b = b.next
return None
扫一扫
117
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
