0. 总结
双指针是一个强大的trick,广泛应用在数组或链表结构的问题中,一般而言,它可以将问题的时间复杂度由O(n^2)降到O(n),将问题的空间复杂度降到O(1)。
常见的用法:环形链表里使用快慢指针、数组里使用左右指针
1. 移动零
class Solution(object):
def moveZeroes(self, nums):
"""
:type nums: List[int]
:rtype: None Do not return anything, modify nums in-place instead.
聪明解法
1. 两个指针,i指针迭代,j指针表示(从左往右)非零元素个数的索引,i遇到非零就复制给j
即:把非0元素都往数组前面扔,数组后面都应该是0
https://leetcode-cn.com/problems/move-zeroes/solution/dong-hua-yan-shi-283yi-dong-ling-by-wang_ni_ma/
2. i不是扔,是交换
"""
# j = 0
# for i in xrange(len(nums)):
# if nums[i] != 0:
# nums[j] = nums[i]
# j += 1
# for k in xrange(j, len(nums)):
# nums[k] = 0
j = 0
for i in range(len(nums)):
if nums[i] != 0:
nums[i], nums[j] = nums[j], nums[i]
j += 1
2. 环形链表
# Definition for singly-linked list.
# class ListNode(object):
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution(object):
def hasCycle(self, head):
"""
:type head: ListNode
:rtype: bool
笨办法
有环说明一个节点被指向了两次
使用set存储节点索引
聪明法
节点被访问过,就把值改为True
双指针,一个快指针、一个慢指针,总会相遇
"""
if not head:
return False
slow, fast = head, head
while slow and fast:
slow = slow.next
if fast.next:
fast = fast.next.next
else:
return False
if slow == fast:
return True
return False
3. 回文链表
# Definition for singly-linked list.
# class ListNode(object):
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution(object):
def isPalindrome(self, head):
"""
:type head: ListNode
:rtype: bool
笨办法
链表输出到数组,然后两个指针前后移动检测数组元素是否相等
时间O(2N),空间O(N)
"""
if not head:
False
array = []
node = head
while node:
array.append(node.val)
node = node.next
i, j = 0, len(array) - 1
while i <= j:
if array[i] != array[j]:
return False
i += 1
j -= 1
return True
4. 寻找重复数
287. find-the-duplicate-number
class Solution(object):
def findDuplicate(self, nums):
"""
:type nums: List[int]
:rtype: int
笨办法
暴力搜索
哈希表, 统计元素出现次数, 大于1就返回
聪明办法
快慢指针法
可以将数组表示成一个带环的图: https://pic.leetcode-cn.com/f9104ccbbd4e572a8a9d6b2e7e2f75084b91c045b48e1dfc65cee238460257a1-image.png
快慢指针都从起始位置出发, 慢指针一次走1步, 快指针一次走2步, 直到相遇
然后, 慢指针回到起始位置, 快指针在相遇位置, 两者同时一次走1步, 再次相遇的点即我们要的数
"""
slow, fast = 0, 0
while slow == fast == 0 or slow != fast:
slow, fast = nums[slow], nums[nums[fast]]
slow = 0
while slow != fast:
slow, fast = nums[slow], nums[fast]
return slow
5. 盛最多水的容器
class Solution(object):
def maxArea(self, height):
"""
:type height: List[int]
:rtype: int
笨办法
暴力搜索
聪明办法
双指针法
左右指针分别表示容器的左右边界, 初始值分别为样本的左右边界
当左指针小于右指针时, 左指针右移; 否则, 右指针左移
每次移动时, 计算当前面积, 直到左右指针相遇, 即可得最大面积
https://leetcode-cn.com/problems/container-with-most-water/solution/sheng-zui-duo-shui-de-rong-qi-by-leetcode-solution/
"""
max_area = 0
left, right = 0, len(height) - 1
while left < right:
area = (right - left) * min(height[left], height[right])
max_area = max(max_area, area)
if height[left] < height[right]:
left += 1
else:
right -= 1
return max_area
6. 相交链表
160. intersection-of-two-linked-lists
# 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的某个节点,遍历B的所有节点,相等返回;
遍历A的所有节点执行上面操作;
聪明办法
构造环形链表
A、B同时开始往后走;
A走完了走B;B走完了走A;
若相遇则返回,否则不相交;
"""
pA, pB = headA, headB
is_pa_linked, is_pb_linked = False, False
while pA and pB:
if pA == pB:
return pA
pA, pB= pA.next, pB.next
if not pA and not is_pa_linked:
pA = headB
is_pa_linked = True
if not pB and not is_pb_linked:
pB = headA
is_pb_linked = True
return None
7. 无重复字符的最长子串
longest-substring-without-repeating-characters
class Solution(object):
def lengthOfLongestSubstring(self, s):
"""
:type s: str
:rtype: int
笨办法:
暴力解法
聪明办法:
滑动窗口,两个指针分别指向子串起始位置和结束位置
"""
max_sub_len = 0
tmp_set = set()
i, j = 0, 0
while j < len(s):
while j < len(s) and s[j] not in tmp_set: # j指针向后,直到遇到重复元素
tmp_set.add(s[j])
j += 1
else: # 遇到重复元素,输出以i为起始的最大子串,i后移一位,删除set中的上个i元素
max_sub_len = max(max_sub_len, j - i)
tmp_set.remove(s[i])
i += 1
return max_sub_len