Swift - LeetCode - 相交链表

·  阅读 485

携手创作,共同成长!这是我参与「掘金日新计划 · 8 月更文挑战」的第10天,点击查看活动详情 

题目

给你两个单链表的头节点 headAheadB,请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点,返回 null

图示两个链表在节点 c1 开始相交:

image.png

题目数据 保证整个链式结构中不存在环。

注意, 函数返回结果后,链表必须 保持其原始结构。

自定义评测:

评测系统的输入如下(你设计的程序 不适用 此输入):

  • intersectVal - 相交的起始节点的值。如果不存在相交节点,这一值为 0
  • listA - 第一个链表
  • listB - 第二个链表
  • skipA - 在 listA 中(从头节点开始)跳到交叉节点的节点数
  • skipB - 在 listB 中(从头节点开始)跳到交叉节点的节点数

评测系统将根据这些输入创建链式数据结构,并将两个头节点 headAheadB 传递给你的程序。如果程序能够正确返回相交节点,那么你的解决方案将被视作正确答案。

示例 1:

image.png

  • 输入: intersectVal = 8, listA = [4,1,8,4,5], listB = [5,6,1,8,4,5], skipA = 2, skipB = 3
  • 输出: Intersected at '8'
  • 解释: 相交节点的值为 8 (注意,如果两个链表相交则不能为 0)。 从各自的表头开始算起,链表 A[4,1,8,4,5],链表 B[5,6,1,8,4,5]。 在 A 中,相交节点前有 2 个节点;在 B 中,相交节点前有 3 个节点。

示例 2:

image.png

  • 输入: intersectVal = 2, listA = [1,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
  • 输出: Intersected at '2'
  • 解释: 相交节点的值为 2 (注意,如果两个链表相交则不能为 0)。 从各自的表头开始算起,链表 A[1,9,1,2,4],链表 B[3,2,4]。 在 A 中,相交节点前有 3 个节点;在 B 中,相交节点前有 1 个节点。

示例 3:

image.png

  • 输入: intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
  • 输出: null
  • 解释: 从各自的表头开始算起,链表 A[2,6,4],链表 B[1,5]。 由于这两个链表不相交,所以 intersectVal 必须为 0,而 skipAskipB 可以是任意值。 这两个链表不相交,因此返回 null

方法一:双指针

思路及解法

使用双指针的方法,可以将空间复杂度降至 O(1)。

只有当链表 headAheadB 都不为空时,两个链表才可能相交。因此首先判断链表 headAheadB 是否为空,如果其中至少有一个链表为空,则两个链表一定不相交,返回 nil

当链表headAheadB 都不为空时,创建两个指针 pApB,初始时分别指向两个链表的头节点 headAheadB,然后将两个指针依次遍历两个链表的每个节点。具体做法如下:

  • 每步操作需要同时更新指针 pApB
  • 如果指针 pA 不为空,则将指针 pA 移到下一个节点;如果指针 pB 不为空,则将指针 pB 移到下一个节点。
  • 如果指针pA 为空,则将指针 pA 移到链表 headB 的头节点;如果指针 pB 为空,则将指针 pB 移到链表 headA 的头节点。
  • 当指针 pApB 指向同一个节点或者都为空时,返回它们指向的节点或者 nil

证明 下面提供双指针方法的正确性证明。考虑两种情况,第一种情况是两个链表相交,第二种情况是两个链表不相交。 情况一:两个链表相交

链表 headAheadB 的长度分别是 mn。假设链表 headA 的不相交部分有 a 个节点,链表 headB 的不相交部分有 b 个节点,两个链表相交的部分有 c 个节点,则有 a + c = mb + c = n

  • 如果 a = b,则两个指针会同时到达两个链表相交的节点,此时返回相交的节点
  • 如果 a != b,则指针 pA 会遍历完链表 headA,指针 pB 会遍历完链表 headB,两个指针不会同时到达链表的尾节点,然后指针 pA 移到链表 headB 的头节点,指针 pB 移到链表 headA 的头节点,然后两个指针继续移动,在指针 pA 移动了 a + c + b 次、指针pB 移动了 b + c + a 次之后,两个指针会同时到达两个链表相交的节点,该节点也是两个指针第一次同时指向的节点,此时返回相交的节点。

情况二:两个链表不相交

链表headAheadB 的长度分别是 mn。考虑当 m = nm != n 时,两个指针分别会如何移动:

  • 如果 m = n,则两个指针会同时到达两个链表的尾节点,然后同时变成空值 nil,此时返回 nil
  • 如果 m != n,则由于两个链表没有公共节点,两个指针也不会同时到达两个链表的尾节点,因此两个指针都会遍历完两个链表,在指针 pA 移动了 m + n 次、指针 pB 移动了 n + m 次之后,两个指针会同时变成空值 nil,此时返回 nil

代码

class Solution {
    func getIntersectionNode(_ headA: ListNode?, _ headB: ListNode?) -> ListNode? {
        if nil == headA || nil == headB {
            return nil
        }
        var pA: ListNode? = headA
        var pB: ListNode? = headB
        while pA != pB {
            pA = pA == nil ? headB : pA?.next
            pB = pB == nil ? headA : pB?.next
        }
        return pA
    }
}

extension ListNode: Equatable {
    public static func == (lhs: ListNode, rhs: ListNode) -> Bool {
        return lhs === rhs
    }
}
复制代码

复杂度分析

  • 时间复杂度:时间复杂度:O(m+n),其中 mn 是分别是链表 headAheadB 的长度。两个指针同时遍历两个链表,每个指针遍历两个链表各一次。

  • 空间复杂度:O(1)。

分类:
iOS
标签:
分类:
iOS
标签:
收藏成功!
已添加到「」, 点击更改