Leetcode Day13 双指针

392 判断一个str是不是另一个str的子序列(不用连续)

class Solution:
    def isSubsequence(self, s: str, t: str) -> bool:
        if len(t) < len(s):
            return False
        l = 0
        r = 0
        while l < len(s):
            if s[l] == t[r]:
                l += 1
                r += 1
            else:
                r += 1
            if r >= len(t):
                return l == len(s)
        return True

自己写的双指针, 有点丑陋

class Solution:
    def isSubsequence(self, s: str, t: str) -> bool:
        i, j = 0, 0
        while i < len(s) and j < len(t):
            if s[i] == t[j]:
                i += 1
            j += 1
        return i == len(s)

学习一下标答

15 三数之和(经经典典)

class Solution:
    def threeSum(self, nums: List[int]) -> List[List[int]]:
        nums.sort()
        ans = []
        n = len(nums)
        for i in range(n):
            l = i + 1
            r = n - 1
            if i > 0 and nums[i] == nums[i-1]: # 对i去重
                continue
            while l < r:
                target = 0
                x = nums[i]
                L = nums[l]
                R = nums[r]
                if x + L + R > target:
                    r -= 1
                elif x + L + R < target:
                    l += 1
                else:
                    ans.append([x, L, R])
                    l += 1
                    r -= 1
                    while l < r and  nums[l] == nums[l-1]: # 对l去重, 注意这个部分应该在target == 0的时候才去重
                        l += 1
                    while l < r and  nums[r] == nums[r+1]: # 对r去重, 注意这个部分应该在target == 0的时候才去重
                        r -= 1
        return ans

复杂度分析: $O(n^2)$

206 翻转列表

class Solution:
    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
        dummy = None
        prev = dummy
        cur = head
        while cur:
            nxt = cur.next
            cur.next = prev
            prev = cur
            cur = nxt
        return prev

特别注意这个情况是不能使用dummy head的,
1.是因为翻转过后第一个元素应该是None
2.否则会发生环的情况, 我来具体解释一下:
dummy -> 1 -> 2
dummy <----> 1 -> (经过cur.next = prev)

19 删除列表的倒数第N个节点

class Solution:
    def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:
        # 创建一个虚拟节点，并将其下一个指针设置为链表的头部
        dummy_head = ListNode(0, head)
        
        # 创建两个指针，慢指针和快指针，并将它们初始化为虚拟节点
        slow = fast = dummy_head
        
        # 快指针比慢指针快 n+1 步
        for i in range(n+1):
            fast = fast.next
        
        # 移动两个指针，直到快速指针到达链表的末尾
        while fast:
            slow = slow.next
            fast = fast.next
        
        # 通过更新第 (n-1) 个节点的 next 指针删除第 n 个节点
        slow.next = slow.next.next
        
        return dummy_head.next

几个问题

• fast和slow都从哪里开始
• 为什么需要dummy
• 最后为什么返回dummy.next而不是一开始head的copy
  一个思想解决: 当r到达none是, l应该是倒数第n个, 此时l, r的index分别是len - n, len. 从这个状态一直往回推, 我们可以得到0, n

160 相交链表

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:
        if headA == None or headB == None:
            return None
        l = headA
        r = headB
        while l != r:
            if l == None:
                l = headB
            else:
                l = l.next
            if r == None:
                r = headA
            else:
                r = r.next
        return l

情况1: 有环, 则在相交点遇上对方
情况2: 无环, 则在最小公倍数次数之后在None遇见

18 四数之和

class Solution:
    def fourSum(self, nums: List[int], target: int) -> List[List[int]]:
        nums.sort()
        n = len(nums)
        ans = []

        for i in range(n): 
            for j in range(n - 1, i, -1):
                if i > 0 and nums[i] == nums[i - 1]:
                    continue
                if j < len(nums) - 1 and nums[j] == nums[j + 1]:
                    continue
                l = i + 1
                r = j - 1
                while l < r:
                    cur_sum = nums[i] + nums[j] + nums[l] + nums[r]
                    if cur_sum < target:
                        l += 1
                    elif cur_sum > target:
                        r -= 1
                    else:
                        ans.append([nums[i], nums[j], nums[l], nums[r]])
                        l += 1
                        r -= 1
                        while l < r and nums[l] == nums[l-1]:
                            l += 1
                        while l < r and nums[r] == nums[r + 1]:
                            r -= 1
        return ans  

情况只能说是一模一样, 只需要在三数之和的基础上再套一层for循环即可

复杂度分析: $O(n^3)$

42 接雨水

一个自然的想法是对于一个木桶, 看左边最高和右边最高就可以了, 但这个情况就需要我们用两个数组来储存, 用双指针的方法可以把空间复杂度降下来.

对于一个桶, 如果前缀最大小, 那么这个桶的容量已经可以计算了

class Solution:
    def trap(self, height: List[int]) -> int:
        ans = left = pre_max = suf_max = 0
        right = len(height) - 1
        while left < right:
            pre_max = max(pre_max, height[left])
            suf_max = max(suf_max, height[right])
            if pre_max < suf_max:
                ans += pre_max - height[left]
                left += 1
            else:
                ans += suf_max - height[right]
                right -= 1
        return ans