【LC】相交链表(160)

苏黎世卡

已于 2023-03-18 21:56:48 修改

阅读量57

点赞数 2

分类专栏： LC/牛客-题解文章标签： java Powered by 金山文档

于 2023-02-14 12:32:58 首次发布

本文链接：https://blog.csdn.net/weixin_56952690/article/details/129024590

版权

LC/牛客-题解专栏收录该内容

12 篇文章 0 订阅

订阅专栏

题目描述：

给你两个单链表的头节点 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]

进阶：

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

来源：力扣（LeetCode）

链接：https://leetcode.cn/problems/intersection-of-two-linked-lists

解题思路：

1. 如果两个链表有一个为空，则一定不会相交
2. 如果两个链表都不为空
a. 找到两个链表的最后一个节点，找的过程中记录链表的长度
b. 如果最后一个节点相同则相交，否则不相交
3. 如果相交，找交点
a. 让长的链表先往后走两个链表差值步
b. 两个同时往后走，相遇时机为交点

代码实现：

/**
 * 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) {
        
        //先将A B 分别遍历 求出长度
        //  ls要永远表示最长的  sh永远表示最短的
       ListNode ls = headA;
       ListNode sh = headB;
       if(ls == null || sh == null){
           return null;
       } 
       int lenA = 0;
       int lenB = 0;
        //求A的长度
       while(ls != null){
           lenA++;
           ls = ls.next;
       }
        //求B的长度
       while(sh != null){
           lenB++;
           sh = sh.next;
       }
        //ls和sh重新恢复原来的位置
       ls = headA;
       sh = headB;
       int len = lenA - lenB;
        //如果A短B长 则改变位置 始终保持 ls最长 sh最短
       if(len < 0){
           ls = headB;
           sh = headA;
           len = lenB - lenA;
       }
        //ls先走len步 保证ls和sh在同一起跑线上
       while(len != 0){
           ls = ls.next;
           len--;
       }
        //遍历找相同的位置
       ListNode cur = ls;
       while (cur != null){
           if(ls == sh){ //找到了直接返回
               return ls;
           }
           ls = ls.next;
           sh = sh.next;
       }
       /**
       //此时ls和sh同时走
        while(ls != sh) {
            ls = ls.next;
            sh = sh.next;
        }
        if(ls != null) {
            return ls;
        }
        */
       //否则就没有结点直接为空
        return null;
    }
}