[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] = ;
             headA=headA->next;
         }
         while(headB!=NULL){
             if(m[headB]==) 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();
     ListNode head2();
     ListNode node1();
     ListNode node2();
     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 ;
 }