面试题 02.07. 链表相交

最新推荐文章于 2024-11-03 22:17:06 发布

青w韵

最新推荐文章于 2024-11-03 22:17:06 发布

阅读量314

点赞数

分类专栏：算法题、数据库题、设计类题等文章标签：链表数据结构 leetcode

本文链接：https://blog.csdn.net/qq_42254247/article/details/122907208

版权

算法题、数据库题、设计类题等专栏收录该内容

30 篇文章 0 订阅

订阅专栏

这篇博客探讨了如何在O(n)时间和O(1)空间复杂度下找到两个单链表的交点。首先介绍了使用HashSet的简单解法，然后通过计算链表长度差来确定交点。最后，提出了一种‘环式思考’的方法，通过让两个指针从各自链表的头节点开始，直到它们相遇于交点或同时到达null，从而找到交点。这种方法巧妙地利用了链表的结构特性。

摘要由CSDN通过智能技术生成

题目

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

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

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

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

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/intersection-of-two-linked-lists-lcci
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路

HashSet，很容易想到，最简单的解法就是，把A和B所有走过的节点的地址保存到Set中，从前向后遍历的过程中，如果发现这个节点已经存在，则返回这个节点即可。

	public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        Set<ListNode> sets = new HashSet<>();

        ListNode p1 = headA, p2 = headB;

        while (p1 != null && p2 != null) {
            if (sets.contains(p1)) {
                return p1;
            }

            sets.add(p1);
            
            if (sets.contains(p2)) {
                return p2;
            }

            sets.add(p2);

            p1 = p1.next;
            p2 = p2.next;
        }

        while (p1 != null) {
            if (sets.contains(p1)) {
                return p1;
            }

            p1 = p1.next;
        }

        while (p2 != null) {
            if (sets.contains(p2)) {
                return p2;
            }

            p2 = p2.next;
        }

        return null;
    }

考虑进阶做法，能否使用O(1)的空间和O(n)时间来做，仔细观察就会发现，我们可以一遍计算得到两个链表的长度，如果尾部有公共节点，那么去掉最前面多余的部分就可以了，直接比较。

这种做法的空间是O(1)，时间是O(n) + O(n)，也算O(n)。

	public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        int[] lens = getLens(headA, headB);

        int lenA = lens[0], lenB = lens[1];

        if (lenA == lenB) {
            return sameLenCompare(headA, headB);
        } else if (lenA > lenB) {
            return longCompareShort(headA, headB, lenA, lenB);
        } else {
            return longCompareShort(headB, headA, lenB, lenA);
        }
    }

    ListNode longCompareShort(ListNode p1, ListNode p2, 
    							int lenA, int lenB) {
        int diff = lenA - lenB;

        ListNode p = p1;
        while (diff-- > 0) {
            p = p.next;
        }

        return sameLenCompare(p, p2);
    }

    ListNode sameLenCompare(ListNode p1, ListNode p2) {
        while (p1 != null && p2 != null) {
            if (p1 == p2) {
                return p1;
            }

            p1 = p1.next;
            p2 = p2.next;
        }

        return null;
    }


    int[] getLens(ListNode p1, ListNode p2) {
        int[] lens = new int[]{0, 0};

        while (p1 != null || p2 != null) {
            if (p1 != null) {
                lens[0]++;
                p1 = p1.next;
            }

            if (p2 != null) {
                lens[1]++;
                p2 = p2.next;
            }
        }

        return lens;
    }

一种大神的解法，我没有想出来。我叫他环式思考，也就是说两个人走了相同的路，如果有交点，那么一定会相遇，否则不会。

所以A走了自己的路，再走B的路和 B走了自己的路，再走A的路长度相同，此时，如果有交点，那么交点就是第一次相遇的点。

	public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode p1 = headA, p2 = headB;

        while (p1 != p2) {
            p1 = (p1 != null)? p1.next: headB;
            p2 = (p2 != null)? p2.next: headA;
        }

        return p1;
    }