[leetcode]Intersection of Two Linked Lists

转载地址：http://blog.csdn.net/litoupu/article/details/41555557

查找两个链表的第一个公共节点，如果两个节点的尾节点相同，肯定存在公共节点，换句话说，尾结点不相同肯定没有公共结点。

方法： 长的链表开始多走 （h1的数量 - h2的数量）步，然后和短链表同步往下走，遇到的第一个相同的节点就是最早的公共节点

 原理是  如果链表有公共部分，那么公共部分长度肯定相等，所以二个链表从最后一个元素开始编号，公共起点  编码必须相等。

              如果先让长的链表 先走多出来的长度，二个链表就可以同步寻找公共结点了。

[java]  view plain copy

1. /** 
2.  * Definition for singly-linked list. 
3.  * public class ListNode { 
4.  *     int val; 
5.  *     ListNode next; 
6.  *     ListNode(int x) { 
7.  *         val = x; 
8.  *         next = null; 
9.  *     } 
10.  * } 
11.  */  
12. public class Solution {  
13.     public ListNode getIntersectionNode(ListNode headA, ListNode headB) {  
14.         if(headA == null ||headB == null)return null;  
15.         ListNode h1 = headA;  
16.         ListNode h2 = headB;  
17.         int count1 = 1, count2 = 1;  
18.         while(h1.next != null){  
19.             count1++;  
20.             h1 = h1.next;  
21.         }  
22.         while(h2.next != null){  
23.             count2++;  
24.             h2 = h2.next;  
25.         }  
26.         if(h1 != h2) return null;  
27.         else{  
28.             int count = Math.abs(count1 - count2);  
29.             if(count2 > count1){  
30.                 h1 = headB;  
31.                 h2 = headA;   
32.             }  
33.             else{  
34.                 h1 = headA;  
35.                 h2 = headB;  
36.             }  
37.             while((count--) > 0){  
38.                 h1 = h1.next;  
39.             }  
40.             while(h1 != null&&h2 != null && h1 != h2){  
41.                 h1 = h1.next;  
42.                 h2 = h2.next;  
43.             }  
44.             return h1;  
45.         }  
46.     }  
47. }  

转载地址：https://i-blog.csdnimg.cn/blog_migrate/645389c6ccc6db96177b58e72f8f592c.png

该问题求两个单链表（不存在环）相交的第一个节点，若不相交返回null。

算法分析：

step1:  把headA的尾同headB相连接

判断headA是否同headB相交就可转换成判断headA中是否存在环。

通过slow,fast两个指针遍历headA，slow移动一步，fast移动两步。若存在环，则slow,fast会指向一个相同的地址，称之为碰撞点p.

若不存在环，即fast == null or fast.next == null

step2: 若存在环，则从headA的第一个节点和碰撞点，每次移动一步，则他们相交的时候就是两个链表相交的一个节点。

如图所示，若fast,slow在碰撞点为p，假设环的长度为r，整个链表长度为L，LA之间的长度为a，AP之间的长度p。

若slow走了s步，则fast = 2s。

显然存在 2s = s + n*r  --->  s = n*r=(n-1)*r+L-a.

而s = a+p，带入式子，可得a = (n-1)*r+L-a-p.注意到L-a-p这段距离就是碰到点到相交点的距离，也就是说，从链表第一个节点，碰撞点同时遍历，他们必定会在第一个相交的点碰撞。

注意:最后还需要断开headA与headB。

[java]  view plain copy

1. public class IntersectionNode {  
2.   
3.     public ListNode getIntersectionNode(ListNode headA, ListNode headB) {  
4.         if (headA == null || headB == null)  
5.             return null;  
6.   
7.         ListNode p, q, tmp;  
8.         // step1 把headB链接在headA后  
9.         p = headA;  
10.         while (p.next != null)  
11.             p = p.next;  
12.         tmp = p;  
13.         p.next = headB;  
14.   
15.         // step2 找到碰撞点  
16.         p = headA;  
17.         q = headA;  
18.         while (q != null && q.next != null) {  
19.             p = p.next;  
20.             q = q.next.next;  
21.             if (p == q) {  
22.                 break;  
23.             }  
24.         }  
25.         if (q == null || q.next == null) {  
26.             tmp.next = null;// 切断headA与headB  
27.             return null;  
28.         } else {  
29.             // step3 找到第一个公共节点  
30.             p = headA;  
31.             while (p != q) {  
32.                 p = p.next;  
33.                 q = q.next;  
34.             }  
35.             tmp.next = null;// 切断headA与headB  
36.             return p;  
37.         }  
38.     }  
39.   
40.     //判断链表是否存在环  
41.     public boolean isCircle(ListNode headA) {  
42.         ListNode slow, fast;  
43.         slow = headA;  
44.         fast = headA;  
45.   
46.         while (fast != null && fast.next != null) {  
47.             slow = slow.next;  
48.             fast = fast.next.next;  
49.             if (slow == fast) {  
50.                 break;  
51.             }  
52.         }  
53.         if (fast == null || fast.next == null)  
54.             return false;  
55.         else {  
56.             return true;  
57.         }  
58.     }  
59.   
60.     //通过数组创建链表  
61.     public ListNode createListNodeFromArray(int[] array) {  
62.         ListNode head = new ListNode(array[0]);  
63.         ListNode tmp = head;  
64.         for (int i = 1; i < array.length; i++) {  
65.             ListNode node = new ListNode(array[i]);  
66.             tmp.next = node;  
67.             tmp = node;  
68.         }  
69.         return head;  
70.     }  
71.   
72.     //打印  
73.     public void print(ListNode headA) {  
74.   
75.         ListNode p = headA;  
76.         while (p != null) {  
77.             System.out.print(p.val + " ");  
78.             p = p.next;  
79.         }  
80.         p = null;  
81.     }  
82.   
83.     public static void main(String[] args) {  
84.         IntersectionNode intersection = new IntersectionNode();  
85.         int[] arrayA = { 1, 3, 5, 7, 9 };  
86.         int[] arrayB = { 2, 4, 6, 8, 10 };  
87.         int[] arrayC = { 11, 12, 13 };  
88.   
89.         ListNode headA = intersection.createListNodeFromArray(arrayA);  
90.         ListNode headB = intersection.createListNodeFromArray(arrayB);  
91.         ListNode headC = intersection.createListNodeFromArray(arrayC);  
92.   
93.         //headA同headC相连  
94.         ListNode p = headA;  
95.         while (p.next != null)  
96.             p = p.next;  
97.         p.next = headC;  
98.   
99.         intersection.print(headA);  
100.   
101.         //headB同headC相连  
102.         p = headB;  
103.         while (p.next != null)  
104.             p = p.next;  
105.         p.next = headC;  
106.   
107.         //headA与headB相交  
108.         ListNode node = intersection.getIntersectionNode(headA, headB);  
109.         System.out.println(node.val);  
110.   
111.     }  
112. }