[LeetCode] 160. Intersection of Two Linked Lists

Write a program to find the node at which the intersection of two singly linked lists begins.

For example, the following two linked lists:

A:          a1 → a2
                   ↘
                     c1 → c2 → c3
                   ↗            
B:     b1 → b2 → b3

begin to intersect at node c1.

Notes:

• If the two linked lists have no intersection at all, return null.
• The linked lists must retain their original structure after the function returns.
• You may assume there are no cycles anywhere in the entire linked structure.
• Your code should preferably run in O(n) time and use only O(1) memory.

Solution 1:

先遍历链表，得到链表的长度。在长链表A中先访问lenA - lenB个结点，使剩余需要访问的结点数与短链表B相同。

同时遍历此时的链表A与B至尾端，找出相同的结点。（如有，则返回该结点，无则返回空）。

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

class Solution:
    # @param two ListNodes
    # @return the intersected ListNode
    def getIntersectionNode(self, headA, headB):
        lenA = self.getLen(headA)
        lenB = self.getLen(headB)
        if lenA >= lenB:
            fwd = lenA - lenB
            headA = self.forwardNode(headA, fwd)
        else:
            fwd = lenB - lenA
            headB = self.forwardNode(headB, fwd)
        n = 0
        while n <= min(lenA, lenB) and headA is not None and headB is not None:
            if headA == headB:
                return headA
            else:
                headA = headA.next
                headB = headB.next
                n += 1
        return None
    
    def forwardNode(self, head, distance):
        d = 0
        while (head is not None) and d<distance:
            head = head.next
            d += 1
        return head
    
    def getLen(self, head):
        if head is None:
            return 0
        length = 0
        while head is not None:
            head = head.next
            length += 1
        return length

Solution 2:

同时遍历链表A和B，先遍历至短链表B的尾端，此时将B的尾端指向A， 将A的尾端指向B。

这样对于A，B而言，剩余需要遍历的结点数相同，此时继续同时遍历至两者尾端，如若出现相同结点，则返回当前结点，否则返回空。