算法题解记录6+++相交链表（百日筑基）

题目描述：

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

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

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

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

自定义评测：

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

• intersectVal - 相交的起始节点的值。如果不存在相交节点，这一值为 0
• listA - 第一个链表
• listB - 第二个链表
• skipA - 在 listA 中（从头节点开始）跳到交叉节点的节点数
• 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 中第四个节点) 在内存中指向相同的位置。 

示例 2：

输入：intersectVal = 2, listA = [1,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
输出：Intersected at '2'
解释：相交节点的值为 2 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [1,9,1,2,4]，链表 B 为 [3,2,4]。
在 A 中，相交节点前有 3 个节点；在 B 中，相交节点前有 1 个节点。

示例 3：

输入：intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
输出：null
解释：从各自的表头开始算起，链表 A 为 [2,6,4]，链表 B 为 [1,5]。
由于这两个链表不相交，所以 intersectVal 必须为 0，而 skipA 和 skipB 可以是任意值。
这两个链表不相交，因此返回 null 。

提示：

• listA 中节点数目为 m
• listB 中节点数目为 n
• 1 <= m, n <= 3 * 104
• 1 <= Node.val <= 105
• 0 <= skipA <= m
• 0 <= skipB <= n
• 如果 listA 和 listB 没有交点，intersectVal 为 0
• 如果 listA 和 listB 有交点，intersectVal == listA[skipA] == listB[skipB]

解题准备：

        1.了解链表：链表有值域和指针域，本题链表单向，也就是节点px找不到px-1，只能找到px-2。

        2.了解基础操作：题目明显涉及到查找，而其它的操作基本没有。

        3.模拟操作：

                1st.如果给你一个节点Pd和链表X，要求：找到X中是否存在Pd，怎么做？经典的遍历一边X，比较X的节点和Pd。【有则返回下标或值，无则返回null】

                2nd.由1st，易知：如果有节点，那么就很容易了。

                现在提供两个链表A、B，那么朴素的思路是：

                拿出A中的一个节点，与B中所有节点比较===就这样循环。

                两层循环即可。【只是算法时间复杂度达到O（m*n），mn分别是AB的节点个数】

                我们不想这么做。

解题难点分析：

        难点1：降低算法时间复杂度。

        既然要求得到两个相同的节点，在随机的情况下，至少需要遍历m+n次。

        已经遍历过的数据，没必要再遍历第二遍。

        所以，我们可以采用一个数组，将遍历过的数据都存储起来，然后进行比对，查看里面有没有相同的数据（在内存层面）。

        难点2：数组的比对，时间复杂度也比较大。

        所以，我们需要一个结构，既能存储数据、又能快速比对。

        也就是哈希表【或者哈希集合HashSet】

        哈希表通过哈希函数的映射，可以快速找到有没有这个数据。

解题思路2：

        哈希表的辅助，提供了空间换时间的方法，不过还可以使用双指针来辅助解题。

        这个思路我并不太理解，只是会写代码，在此分享自己的想法。

        采用双指针，我们就思考另一个问题：

                如果两个链表长度一致，怎么判断它们是否相交？

                易得：如果两个链表相交，一定有从某个节点K开始，后面的节点都一样，假设从K到末尾有n个节点。

                也就是说，其实从A、B的头节点开始，二者到K的距离也一致，所以两指针只要同步行动，一定能找到一个K满足条件，或者同步到达null。

        难点1：两个链表长度大概不一致。

                也就是说，如果都从A、B的头节点开始，pA到达K时，pB不指向K。

                对于A，使a表示K之前的节点个数。对于B，使b表示K之前的节点个数。

                a与b不同。

                但是有一个规律：K及K后的n个节点长度相同。

                如果A、B分别如下图：

                那么在多次遍历的情况下，有序列：

                A：abc34 abc34 abc34 abc34

                B:  1234 1234 1234 1234 1234

                实验其它的，最后总是能对齐，也就是说，假设两个指针同时指向null，就说明没有相交的，同时指向一个节点，就说明该节点为相交节点。

                当迭代次数为m*n时，双指针同时指向各自的末尾。

                这种思想的本质，就是使用双指针替代了双层遍历，并且永远是短的链表，最先与长的链表对齐。                

哈希表代码：

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        HashMap<ListNode, Integer> temp = new HashMap<>();
        while(headA!=null){
            temp.put(headA, 1);
            headA=headA.next;
        }
        while(headB!=null){
            if(temp.containsKey(headB)){
                return headB;
            }
            headB=headB.next;
        }

        return null;
    }
}

以上内容即我想分享的关于力扣热题6的一些知识。

        我是蚊子码农，如有补充，欢迎在评论区留言。个人也是初学者，知识体系可能没有那么完善，希望各位多多指正，谢谢大家。