LeetCode 160.相交链表

给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回 null 。

图示两个链表在节点 c1 开始相交：

题目数据 保证 整个链式结构中不存在环。

注意，函数返回结果后，链表必须 保持其原始结构 。

自定义评测：

评测系统 的输入如下（你设计的程序 不适用 此输入）：

1、intersectVal - 相交的起始节点的值。如果不存在相交节点，这一值为 0

2、listA - 第一个链表

3、listB - 第二个链表

4、skipA - 在 listA 中（从头节点开始）跳到交叉节点的节点数

5、skipB - 在 listB 中（从头节点开始）跳到交叉节点的节点数

评测系统将根据这些输入创建链式数据结构，并将两个头节点 headA 和 headB 传递给你的程序。如果程序能够正确返回相交节点，那么你的解决方案将被 视作正确答案 。

示例 1：

输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,6,1,8,4,5], skipA = 2, skipB = 3

输出：Intersected at '8'

解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。

从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,6,1,8,4,5]。

在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。

———请注意相交节点的值不为 1，因为在链表 A 和链表 B 之中值为 1 的节点 (A 中第二个节点和 B 中第三个节点) 是不同的节点。换句话说，它们在内存中指向两个不同的位置，而链表 A 和链表 B 中值为 8 的节点 (A 中第三个节点，B 中第四个节点) 在内存中指向相同的位置。

提示：

1、listA 中节点数目为 m

2、listB 中节点数目为 n

3、1 <= m, n <= 3 * 104

4、1 <= Node.val <= 105

5、0 <= skipA <= m

6、0 <= skipB <= n

7、如果 listA 和 listB 没有交点，intersectVal 为 0

8、如果 listA 和 listB 有交点，intersectVal == listA[skipA] == listB[skipB]

思路：

先遍历求得连个链表的长度，较长的先走两个链表长度的差值，然后连个链表一起走，如果走到同一个结点，证明是相交链表，如果循环走完，则不是

代码：

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        if (headA==null||headB==null){
            return null;
        }
        ListNode pl=headA;//长
        ListNode ps=headB;//短
        //1.分别求长度
        int lenA=0;
        int lenB=0;
        while (pl!=null){
            lenA++;
            pl=pl.next;
        }
        while (ps!=null){
            lenB++;
            ps=ps.next;
        }
        //需要重新修改指向
        pl=headA;
        ps=headB;

        //2.已知两个链表的长度
        int len=lenA-lenB;
        if (len<0){
            pl=headB;
            ps=headA;
            len=lenB-lenA;
        }

        //3.让最长的链表走|len|步
        for (int i = 0; i < len; i++) {
            pl=pl.next;
        }
        //4.一人一一步直到相遇
        while (pl!=ps){

            pl=pl.next;
            ps=ps.next;
        }
        return pl;
    }
}

进阶：你能否设计一个时间复杂度 O(m + n) 、仅用 O(1) 内存的解决方案？

思路：

两个链表一起遍历，当链表一走到空，使其指向链表2的头节点，链表二同理，如果是相交链表，变换指向之后遍历会相遇在同一个结点，如果遍历完为null，则不是相交链表，这样时间复杂度为O(m + n)，空间复杂度为O(1)

代码：

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        if(headA==null||headB==null){
            return null;
        }
        ListNode p1=headA;
        ListNode p2=headB;
        while(p1!=p2){
            p1=p1==null?headB:p1.next;
            p2=p2==null?headA:p2.next;
        }
        if(p1!=null){
            return p1;
        }
        return null;
    }
}