160. 相交链表

题目：
给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。
A: a1 → a2
↘
c1 → c2 → c3
↗
B: b1 → b2 → b3
图示两个链表在节点 c1 开始相交。

题目来自LeetCode第160题，和“剑指 Offer 52. 两个链表的第一个公共节点”也是同一个题目。

思路：
两个链表交叉点后的节点都是一样的，包括值和next的引用。遍历两链表长度，长的先走相差的步数，再一起遍历找一样的第一个节点就可以啦。

代码：

/**
 * 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 headACount = 0;
        int headBCount = 0;
        ListNode headATemp = new ListNode();
        headATemp = headA;
        while(headATemp.next != null){
            headACount++;
            headATemp = headATemp.next; 
        }
        ListNode headBTemp = new ListNode();
        headBTemp = headB;
        while(headBTemp.next != null){
            headBCount++;
            headBTemp = headBTemp.next; 
        }
        ListNode headAReal = new ListNode();
        headAReal = headA;
        if(headACount > headBCount){
            int temp = headACount - headBCount;
            while(temp > 0){
                temp--;
                headAReal = headAReal.next;
            }
        }
        ListNode headBReal = new ListNode();
        headBReal = headB;
        if(headBCount > headACount){
            int temp = headBCount - headACount;
            while(temp > 0){
                temp--;
                headBReal = headBReal.next;
            }
        }
        while(headAReal != null && headBReal != null){
            if(headAReal == headBReal){
                return new ListNode(headAReal.val,null);
            }
            headAReal = headAReal.next;
            headBReal = headBReal.next;
        }
        return null;
    }
}

补充：
评论有其他解法。
遍历时第一次结束后并不对调。这样会逐步错位，遍历各种结果，直到满足要求。

如上图，两个链表最开始状态是a1 a2 a3 c1…，b1 b2 b3 b4 c1…，交点是c1。两个链表遍历到末尾后都从头开始遍历，那么每轮遍历时进行的比较的数据就会错位，错位的距离就是两个链表长度的差值，这样一直错位查询下去，如果有相交最终一定会遍历到该结点。

    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        if(headA == null || headB == null) {
        	return null;
        } 
        ListNode n1 = headA;
        ListNode n2 = headB;      
        while(n1 != n2){
        	//遍历完自己后继续遍历自己
            n1 = n1 == null ? headA : n1.next; 
            n2 = n2 == null ? headB : n2.next;
        }
        return n1;
    }

另外一种方法时，利用公共部分的c来查找。两个链表遍历到最后一定是某时刻剩余未遍历到的都是c。
对于a链表来讲，遍历一次是a+c，a是自己单独的部分，c是相交后部分。
对于b链表来讲，遍历一次是b+c，b是自己单独的部分，c是相交后部分。
a和b如果相等，那么一次就能遍历出结果，如果a和b不等，那么如何让c前面的部分相等呢？
当两个链表再互相遍历一轮，就一定相等了。即
对于a链表来讲，遍历两次是a+c+b+c。
对于b链表来讲，遍历两次是b+c+a+c。
前面的a+c+b = b+c+a，这两部一定相等。因此最多遍历两遍就可以找到公共的c。

    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        if(headA == null || headB == null) {
        	return null;
        } 
        ListNode n1 = headA;
        ListNode n2 = headB;   
        while(n1 != n2){
        	//遍历完自己后遍历对方
            n1 = n1 == null ? headB : n1.next;
            n2 = n2 == null ? headA : n2.next;
        }
        return n1;
    }