Intersection of Two Linked Lists

Introduction

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

For example, the following two linked lists:

begin to intersect at node c1.

Example 1:

• Input: intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
• Output: Reference of the node with value = 8
• Input Explanation: The intersected node’s value is 8 (note that this must not be 0 if the two lists intersect). From the head of A, it reads as [4,1,8,4,5]. From the head of B, it reads as [5,0,1,8,4,5]. There are 2 nodes before the intersected node in A; There are 3 nodes before the intersected node in B.

Example 2:

• Input: intersectVal = 2, listA = [0,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
• Output: Reference of the node with value = 2
• Input Explanation: The intersected node’s value is 2 (note that this must not be 0 if the two lists intersect). From the head of A, it reads as [0,9,1,2,4]. From the head of B, it reads as [3,2,4]. There are 3 nodes before the intersected node in A; There are 1 node before the intersected node in B.

Example 3:

• Input: intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
• Output: null
• Input Explanation: From the head of A, it reads as [2,6,4]. From the head of B, it reads as [1,5]. Since the two lists do not intersect, intersectVal must be 0, while skipA and skipB can be arbitrary values.
• Explanation: The two lists do not intersect, so return null.

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

Simple lookup solution:

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */

type pair struct {
    a *ListNode
    b *ListNode
}

func getIntersectionNode(headA, headB *ListNode) *ListNode {

    seenA := make(map[*ListNode]bool)
    seenB := make(map[*ListNode]bool)

    for i, j := headA, headB; i != nil || j != nil; {

        if i != nil {

            if _, ok := seenB[i]; ok {
                return i
            }

            seenA[i] = true
            i = i.Next
        }

        if j != nil {

            if _, ok := seenA[j]; ok {
                return j
            }

            seenB[j] = true
            j = j.Next
        }

    }

    return nil
}

Loop solution:

func getIntersectionNode(headA, headB *ListNode) *ListNode {

    if headA == nil || headB == nil {
        return nil
    }

    list := []*ListNode { headA, headB }

    ip, jp := 0, 1

    for i, j := list[ip], list[jp]; ip < 2; i, j = i.Next, j.Next {

        if i == j {
            return i
        }

        if i == nil {
            ip++
            i = list[ip % 2]
        }

        if j == nil {
            jp++
            j = list[jp % 2]            
        }

        if i == j {
            return i
        }
    }

    return nil
}

Explanation

Lookup solution is based on caching approach of seen values from both lists. Loop solution is using fact that both lists have the same tail. Therefore, we have two cases: * a) Equal length of both lists The solution is simple, both pointers definitely will meet on common node. * b) Different length of both lists In this case we need to switch pointer i to headB and j to headA as soon one of them will reach the end. Suppose length of list A is a, and length of list B is b. We can equalize both iterators if smaller will do additional abs(a-b) steps.