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:

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.

第一种方法:

暴力破解：

依次循环每一个节点，比较是否相等。时间复杂度O(Length(A)*Length(B)),空间复杂度O（1）

public static LinkNode getIntersectionNode(LinkNode headA, LinkNode headB) {
        	if(headA == null || headB == null){
            		return null;
        	}
        	LinkNode tmp = headA;
        	while(headB != null){
            		headA = tmp;
            		while(headA != null){
               	 		if(headB == headA){
                    			return headB;
                		}else{
                    			headA = headA.next;
                		}
            		}
            		headB = headB.next;
        	}
        	return null;
       }
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */

最后的执行结果是time Limited，好吧。。。。。。。。。。。。。

第二种

哈希表法，

将其中的一个链表散列到哈希表里，然后查找另一个链表的元素是不是在哈希表里时间复杂度O(lengthA+lengthB)，空间复杂度O(lengthA)或O(lengthB)。

第三种：

1、先各自遍历每一个链表，计算链表长度，都到达末尾时，如果末尾节点相同，说明有交集，否则返回null

2、如果有交集的话，先让长链表走|Length（A）-Length（B）|步，再同时走，比较可以找到

时间复杂度O(lengthA+lengthB)，空间复杂度O(1)

/**
 * 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;
        }
        int c1=1;
        int c2=1;
        ListNode h1 = headA;
        ListNode h2 = headB;
        while(h1.next != null){
            c1++;
            h1 = h1.next;
        }
        while(h2。next != null){
            c2++;
            h2 = h2.next;
        }
        if(h1 != h2){
            return null;
        }
        if(c1 > c2){
            int c = c1 - c2;
            while(c > 0){
                headA = headA.next;
                c--;
            }
        }
        if(c1 < c2){
            int c = c2 - c1;
            while(c > 0){
                headB = headB.next;
                c--;
            }
        }
        while(headA != null && headA != headB){
            headA = headA.next;
            headB = headB.next;
        }
        return headA;
    }
}

Runtime: 520 ms

第四种：

先分析下，

第一种方法是暴力破解，思路很简单，效率去很低（这是我自己可以想到的，哎，脑子还是太笨。。。）

第二种方法是哈希表法，利用哈希表的查找时间复杂度是O(1)的性质，最终的缺点在于空间复杂度上，需要create一个HashSet，（压根没有想到哈希表，不善于使用hash，以后得记住点这个，作为解题得思路）

第三种方法比较好，计算出两条链表的长度差，先让长的走，然后一起走，如果两条链有交集，那么，|length（A）-Length（B）|就一定不是，因此可以去掉这些无用的遍历，即让长的先走|length（A）-Length（B）|，

到这一步之后怎么继续改进？

能不能不计算链表长度就得到这个差值？答案是可以。

作者提供的解题方法：

• Brute-force solution (O(mn) running time, O(1) memory):

  For each node a i in list A, traverse the entire list B and check if any node in list B coincides with a i .

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

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

同时遍历两个链表（在这里就可以先进行比较了，找到就返回），当其中的一个链表到达尾部时，另一个一定是在差值的那个地方，那么就是找到这个差值了，然后再同时遍历。依次maintain两个pointer Pa和Pb，当到达尾部时（假设Pa先到达尾部，说明headB长），pa=headB，pb=headA

这是作者提供的解法。

/**
 * 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 pa = headA;
        ListNode pb = headB;
        while(pa != null && pb != null){
            if(pa == pb){
                return pa;
            } 
            pa = pa.next;
            pb = pb.next;
        }
        //
        if(pa == null && pb != null){//链表b比较长
            pa = headB;
            while(pb != null){//
                pa = pa.next;
                pb = pb.next;
            }
            pb = headA;
            while(pa !=null && pb != null){
                if(pa == pb){
                    return pa;
                }
                pa = pa.next;
                pb = pb.next;
            }
        }else if(pb == null && pa != null){
            pb = headA;
            while(pa != null){
                pb = pb.next;
                pa = pa.next;
            }
            pa = headB;
            while(pa != null && pb != null){
                if(pa == pb){
                    return pa;
                }
                pa = pa.next;
                pb = pb.next;
            }
        }
        return null;
    }
}

Runtime: 504 ms

还是自己的脑子不够活泛，不能从多角度思考问题，之前自己想的时候一直在想怎么能够快速定位到这个交集点，总是没有头绪，感觉除了一个个遍历比较再没有其他的方法。再看别人写的，发现改进还是有的。不考虑空间复杂度的话，将一个数组映射到hash表里，然后遍历第二个数组，可以用O（1）的时间找到是否有相等的量。考虑空间复杂度的话，那么就要考虑怎么减少遍历的次数，就是去掉不必要的比较。比如说，如果两个链表存在交集点，如果两个链表长度相等，那么就没有冗余的比较了，如果链表长度不相等，那么较长链表（假设B长）的前Length（B）-Length（A）个元素与较短链表的比较就是冗余的，因为前Length（B）-Length（A）个元素不可能是交集点。所以考虑如何跳过这些元素（比如找到计算链表长度，然后再跳过差值，显然计算链表长度的时间要小于遍历这些元素并且比较的时间，一开始思维总是感觉遍历比较简单就觉得花的时间少）。作者提出的这个计算差值的方法还是不错的（learning...）