[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:

begin to intersect at node c1.

Example 1:

Input: intersectVal = 8, listA = [4,1,8,4,5], listB = [5,6,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,6,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 = [1,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 [1,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.
• Each value on each linked list is in the range [1, 10^9].
• Your code should preferably run in O(n) time and use only O(1) memory.

相交链表。

给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。

两种思路，一个是需要求出两个链表各自的长度，当两者不想等的时候，需要先遍历长的链表，使得其剩下的长度要跟短的链表长度相等，再去找两者的交点。如图所示就是需要先让B移动到node.value = 0的那个节点，再遍历A和B，看看交点在哪里。

时间O(n)

空间O(1)

JavaScript实现

/**
 * @param {ListNode} headA
 * @param {ListNode} headB
 * @return {ListNode}
 */
var getIntersectionNode = function(headA, headB) {
    // corner case
    if (headA === null || headB === null) {
        return null;
    }

    // normal case
    let lenA = len(headA);
    let lenB = len(headB);
    if (lenA > lenB) {
        while (lenA !== lenB) {
            headA = headA.next;
            lenA--;
        }
    } else {
        while (lenA !== lenB) {
            headB = headB.next;
            lenB--;
        }
    }
    while (headA !== headB) {
        headA = headA.next;
        headB = headB.next;
    }
    return headA;
};

var len = function(head) {
    let res = 1;
    while (head !== null) {
        res++;
        head = head.next;
    }
    return res;
}

Java实现

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        // corner case
        if (headA == null || headB == null) {
            return null;
        }

        // normal case
        int lenA = len(headA);
        int lenB = len(headB);
        if (lenA > lenB) {
            while (lenA != lenB) {
                headA = headA.next;
                lenA--;
            }
        } else {
            while (lenA != lenB) {
                headB = headB.next;
                lenB--;
            }
        }
        while (headA != headB) {
            headA = headA.next;
            headB = headB.next;
        }
        return headA;
    }

    private int len(ListNode head) {
        int len = 1;
        while (head != null) {
            head = head.next;
            len++;
        }
        return len;
    }
}

另外一种思路是不求两个链表的长度，分别遍历A和B。如果按照此例，遍历完A和B的时候并不能找到两者的交点，此时可以将A的末尾接上B（A+B），或者将B的末尾接上A（B+A），这样保证了两者遍历的长度相等，就一定能找到交点。这个例子给的不是特别好，因为遍历的时候，程序很可能在8之前的那个1的node就退出循环了。但是如果这个节点不相等，程序会在8的地方退出。

A: 4 - 1 - 8 - 4 - 5 - 5 - 0 - 1 - 8 - 4 - 5

B: 5 - 0 - 1 - 8 - 4 - 5 - 4 - 1 - 8 - 4 - 5

时间O(m + n), A和B的长度和

空间O(1)

JavaScript实现

/**
 * @param {ListNode} headA
 * @param {ListNode} headB
 * @return {ListNode}
 */
var getIntersectionNode = function(headA, headB) {
    // corner case
    if (headA === null || headB === null) {
        return null;;
    }

    // normal case
    let a = headA;
    let b = headB;
    while (a !== b) {
        a = a === null ? headB : a.next;
        b = b === null ? headA : b.next;
    }
    return a;
};

Java实现

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        if (headA == null || headB == null) return null;
        ListNode a = headA;
        ListNode b = headB;
        while (a != b) {
            a = a == null ? headB : a.next;
            b = b == null ? headA : b.next;
        }
        return a;
    }
}

LeetCode 题目总结