380. Intersection of Two Linked Lists

380. Intersection of Two Linked Lists

Description:

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

Example
Example 1:

Input:
A: a1 → a2
↘
c1 → c2 → c3
↗
B: b1 → b2 → b3
Output: c1
Explanation ：begin to intersect at node c1.
Example 2:

Input:
Intersected at 6
1->2->3->4->5->6->7->8->9->10->11->12->13->null
6->7->8->9->10->11->12->13->null
Output: Intersected at 6
Explanation：begin to intersect at node 6.
Challenge
Your code should preferably run in O(n) time and use only O(1) memory.

Notice
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.

Main Idea:

There are two steps to solve this problem. The first one is to hash one of the list( key: current node, value: next node). Then, iterate the other list, find the first node found in the hash table. The first node can be found in hash table, this node is intersection node.

Tips/Notes:

1. Node pointer here is an object. If two node pointer to the same node, then they are pointing to the same object.

Code:

/**
 * Definition of singly-linked-list:
 * class ListNode {
 * public:
 *     int val;
 *     ListNode *next;
 *     ListNode(int val) {
 *        this->val = val;
 *        this->next = NULL;
 *     }
 * }
 */

class Solution {
public:
    /**
     * @param headA: the first list
     * @param headB: the second list
     * @return: a ListNode
     */
    ListNode * getIntersectionNode(ListNode * headA, ListNode * headB) {
        // write your code here
        unordered_map<ListNode *, ListNode *> hash;
        // hash the headA
        while(headA){
            hash[headA] = headA->next;
            headA = headA->next;
        }
        
        ListNode * res;
        
        while(headB){
        	// if the node can be found in the hash table, it means it's in headA. The first time in hash table is the Intersection node.
            if(hash.find(headB) != hash.end()){
                res = headB;
                return res;
            }
            headB = headB->next;
        }
        return nullptr;
    }
};