LeetCode: Intersection of Two Linked Lists 解题报告

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.

Credits:
Special thanks to @stellari for adding this problem and creating all test cases.

 

SOLUTION 1:

1.各自遍历链表，分别取得长度；

2.较长一条链表移动abs（lengthA-lengthB)个节点；

3.同时移动指针，判断是否相等。

 

(O(n+m) running time, O(1) memory)

 

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {

        //my solution
        if(headA == NULL && headB == NULL) {
            return NULL;
        }
        if(headA && headB) {
            ListNode *it;
            it = headA;
            int lengthA = 0;
            while(it) {
                lengthA++;
                it = it->next;
            }
            it = headB;
            int lengthB = 0;
            while(it) {
                lengthB++;
                it = it->next;
            }
            it = NULL;
            ListNode *itA = headA;
            ListNode *itB = headB;
    
            if(lengthA > lengthB) {
                for(int i = 0; i < lengthA-lengthB; i++) {
                    itA = itA->next;
                }
            } else {
                for(int i = 0; i < lengthB-lengthA; i++) {
                    itB = itB->next;
                }
            }
            while(itA != itB) {
                itA = itA->next;
                itB = itB->next;
            }
            return itA;
        } else {
            return NULL;
        }
}

 

 SOLUTION 2:

LeetCode提供的解法：

• Hashset solution (O(n+m) running time, O(n) or O(m) memory):

  Traverse list A and store the address / reference to each node in a hash set. Then check every node b_i in list B: if b_i appears in the hash set, then b_i is the intersection node.

　　这样做比较占用空间。没有去写这个解法的代码；

SOLUTION 3:

LeetCode的解法：

Two pointer solution (O(n+m) running time, O(1) memory):

• Maintain two pointers pA and pB initialized at the head of A and B, respectively. Then let them both traverse through the lists, one node at a time.
• When pA reaches the end of a list, then redirect it to the head of B (yes, B, that's right.); similarly when pB reaches the end of a list, redirect it the head of A.
• If at any point pA meets pB, then pA/pB is the intersection node.
• To see why the above trick would work, consider the following two lists: A = {1,3,5,7,9,11} and B = {2,4,9,11}, which are intersected at node '9'. Since B.length (=4) < A.length (=6), pB would reach the end of the merged list first, because pB traverses exactly 2 nodes less than pA does. By redirecting pB to head A, and pA to head B, we now ask pB to travel exactly 2 more nodes than pA would. So in the second iteration, they are guaranteed to reach the intersection node at the same time.
• If two lists have intersection, then their last nodes must be the same one. So when pA/pB reaches the end of a list, record the last element of A/B respectively. If the two last elements are not the same one, then the two lists have no intersections.

其实本质和solution 1 差不多，都是把两个链表的长度差消去。但是这样写感觉很屌。

自己写的代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {

        // solution 3
        if(headA == NULL && headB == NULL) {
            return NULL;
        }
        if(headA && headB){
            ListNode *pA = headA;
            ListNode *pB = headB;
            while(pA != pB){
                if(pA == NULL && pB == NULL){
                    return NULL;
                }
                if(pA == NULL){
                    pA = headB;
                }
                if(pB == NULL){
                    pB = headA;
                }
//if the intersection is the last node
                if(pA == pB){
                    return pA;
                }
                pA = pA->next;
                pB = pB->next;
            }
            return pA;
        }
        return NULL;
    }
};