[LeetCode] 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.

Hide Tags

 Linked List

 

---

     两个单项链表，判断是否存在交集，如上图很清晰，最直观的方法是

for  list1 begin to last

　　for list2 begin to last

　　　　if list2==list1 success

　　end

end　　

    时间是O(nm)，空间挺少的O(1)。如何提高呢？

1. 遍历list1 ，将其节点存在hash_table
2. 遍历list2，如果已经在hash_table中，那么存在

    利用hash_table 可以提升时间到O(n+m)，可是空间变O(n)了

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        unordered_map<ListNode*,int> m;
        while(headA!=NULL){
            m[headA] = 1;
            headA=headA->next;
        }
        while(headB!=NULL){
            if(m[headB]==1) return headB;
            headB=headB->next;
        }
        return NULL;
    }
};

 

　　那题目的最好解法，这技巧问题阿，遍历list1 后接着遍历list2，同时，遍历list2然后遍历list1，这样两个遍历的长度是一样的O(n+m)，怎么判断相等呢？

 

list1:    O O O O O ⑴ ⑵ ⑶

list2:    □ □ □ □ ⑴ ⑵ ⑶

　　假如list 如上，⑴ ⑵ ⑶ 为相同的节点，那么遍历list1 这样便是这样：

O O O O O ⑴ ⑵ ⑶ □ □ □ □ ⑴ ⑵ ⑶

　　遍历list2 便是这样。

□  □ □ □ ⑴ ⑵ ⑶ O O O O O ⑴ ⑵ ⑶

 

合在一起看看：

O　　O　　O　　O　　O　　⑴　　⑵　　⑶　　□　　 □　　□　　□　　 ⑴　　⑵　　⑶

□　　 □　　□ 　　□　　⑴　　⑵　　⑶　　O　　O　　O　　O　　O　　⑴　　⑵　　⑶

 

    好了，现在规律出来了。这个逻辑出来明显，主要麻烦是在遍历一个结束后接上第二个，直接改链表不好，所以，使用flag 控制。

算法逻辑：

1. 判断list 是否有NULL 情况
2. 同时遍历 两个新链表
3. 如果节点地址相同，返回
4. 如果不相同继续遍历
5. 遍历结束返回NULL

#include <iostream>
#include <unordered_map>
using namespace std;

/**
 * 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) {
        unordered_map<ListNode*,int> m;
        while(headA!=NULL){
            m[headA] = 1;
            headA=headA->next;
        }
        while(headB!=NULL){
            if(m[headB]==1) return headB;
            headB=headB->next;
        }
        return NULL;
    }
};
*/
class Solution{
public:
    ListNode* getIntersectionNode(ListNode *headA,ListNode * headB)
    {
        ListNode * h1=headA;
        ListNode * h2=headB;
        if(headA==NULL||headB==NULL)    return NULL;
        bool flag1=true,flag2=true;
        while(headA!=NULL&&headB!=NULL){
            if(headA==headB)    return headA;
            headA=headA->next;
            headB=headB->next;
            if(headA==NULL&&flag1){ headA=h2;   flag1 =false;}
            if(headB==NULL&&flag2){ headB=h1;   flag2 =false;}
        }
        return NULL;
    }
};

int main()
{
    ListNode head1(1);
    ListNode head2(2);
    ListNode node1(3);
    ListNode node2(4);
    head1.next = &node1;
    node1.next = &node2;
    head2.next = &node2;
    Solution sol;
    ListNode *ret = sol.getIntersectionNode(&head1,&head2);
    if(ret==NULL)   cout<<"NULL"<<endl;
    else    cout<<ret->val<<endl;
    return 0;
}