Intersection of Two Linked Lists

本文介绍了一种寻找两个单链表开始相交节点的方法,适用于LeetCode上的两链表交点问题。该方法能够在O(n)的时间复杂度内完成,并且只使用O(1)的空间,满足题目要求。

问题来源:https://leetcode.com/problems/intersection-of-two-linked-lists/

/**
 * 
 * <p>
 * ClassName IntersectionOfTwoLinkedLists
 * </p>
 * <p>
 * Description Write a program to find the node at which the intersection of two singly linked lists begins. For example, the
 * following two linked lists:
 *       A: a1 → a2 
 *                  ↘ c1 → c2 → c3 
 *                  ↗ 
 * B: b1 → b2 → b3 
 * begin to intersect at node c1. Notes: If the two linked lists have no intersection
 * at all, return null. The linked lists must retain their original structure after the function returns. You may assume there are
 * no cycles anywhere in the entire linked structure. Your code should preferably run in O(n) time and use only O(1) memory.
 * </p>
 * 
 * @author TKPad wangx89@126.com
 *         <p>
 *         Date 2015326日 下午1:30:20
 *         </p>
 * @version V1.0.0
 *
 */
class ListNode {
    int val;
    ListNode next;

    ListNode(int x) {
        val = x;
        next = null;
    }
}

public class IntersectionOfTwoLinkedLists {
    ListNode temp;
    // Last executed input: Intersected at '60':
    // {1,3,5,7,9,11,13,15,17,19,21,23,25,27,29,31,33,35,37,39,41,43,45,47,49,51,53,55,57,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94},
    // {2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32,34,36,38,40,42,44,46,48,50,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94}
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        if (headA != null && headB != null) {
            if (headA.val < headB.val) {
                while (headA.val < headB.val) {
                    if (headA.next != null) {
                        headA = headA.next;
                    } else {
                        break;
                    }
                }
                if (headA.val != headB.val) {
                    temp = getIntersectionNode(headA, headB.next);
                } else {
                    temp = headA;
                }
            } else if (headA.val > headB.val) {
                while (headB.val < headA.val) {
                    if (headB.next != null) {
                        headB = headB.next;
                    } else {
                        break;
                    }
                }
                if (headA.val != headB.val) {
                    temp = getIntersectionNode(headA.next, headB);
                } else {
                    temp = headA;
                }
            } else {
                temp = headA;
            }
        }
        return temp;
    }

    public static void main(String[] args) {
        // Runtime Error Message: Line 38: java.lang.StackOverflowError
        // Last executed input: No intersection: {1,3,5,7,9,11,13,15,17,19,21}, {2}

        // Last executed input: No intersection: {1}, {2,4,6,8,10,12,14,16,18,20,22}

        ListNode l1 = new ListNode(18);
        // ListNode l11 = new ListNode(10);
        // l1.next = l11;

        ListNode l2 = new ListNode(1);
        ListNode l3 = new ListNode(4);
        ListNode l4 = new ListNode(6);
        ListNode l5 = new ListNode(8);
        ListNode l6 = new ListNode(10);
        ListNode l7 = new ListNode(12);
        ListNode l8 = new ListNode(14);
        ListNode l9 = new ListNode(16);
        ListNode l10 = new ListNode(18);
        l2.next = l3;
        l3.next = l4;
        l4.next = l5;
        l5.next = l6;
        l6.next = l7;
        l7.next = l8;
        l8.next = l9;
        l9.next = l10;
        ListNode intersectionNode = new IntersectionOfTwoLinkedLists().getIntersectionNode(l1, l2);
        if (intersectionNode != null)
            System.out.println(intersectionNode.val);
        else
            System.out.println("null");
    }
}
以下对使用双指针 `p` 和 `q` 遍历链表来求解两个链表相交节点的逻辑和原理进行分析。 ### 代码逻辑 ```cpp /** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */ class Solution { public: ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) { ListNode* p = headA; ListNode* q = headB; while (p != q) { p = p ? p->next : headB; q = q ? q->next : headA; } return p; } }; ``` ### 原理分析 1. **初始化指针**:定义两个指针 `p` 和 `q`,分别指向链表 `A` 和链表 `B` 的头节点。 2. **遍历链表**:使用 `while` 循环,只要 `p` 不等于 `q`,就继续循环。在每次循环中,如果 `p` 不为空,就将 `p` 指向下一个节点;如果 `p` 为空,就将 `p` 指向链表 `B` 的头节点。对于 `q` 指针同理,如果 `q` 不为空,就将 `q` 指向下一个节点;如果 `q` 为空,就将 `q` 指向链表 `A` 的头节点。 3. **找到相交节点**:当 `p` 等于 `q` 时,循环结束,此时 `p`(或 `q`)所指向的节点就是两个链表的相交节点。如果两个链表不相交,那么最终 `p` 和 `q` 都会指向 `nullptr`。 ### 具体解释 - **相交情况**:假设链表 `A` 的长度为 `m`,链表 `B` 的长度为 `n`,两个链表相交部分的长度为 `k`。那么链表 `A` 不相交部分的长度为 `m - k`,链表 `B` 不相交部分的长度为 `n - k`。当 `p` 遍历完链表 `A` 后,会指向链表 `B` 的头节点;当 `q` 遍历完链表 `B` 后,会指向链表 `A` 的头节点。此时,`p` 和 `q` 走过的路程分别为 `m + (n - k)` 和 `n + (m - k)`,由于 `m + (n - k) = n + (m - k)`,所以 `p` 和 `q` 会在相交节点处相遇。 - **不相交情况**:如果两个链表不相交,那么 `p` 和 `q` 会分别遍历完链表 `A` 和链表 `B`,然后同时指向 `nullptr`,此时 `p` 等于 `q`,循环结束,返回 `nullptr`。 ### 复杂度分析 - **时间复杂度**:$O(m + n)$,其中 `m` 和 `n` 分别是两个链表的长度。因为每个指针最多遍历两个链表各一次。 - **空间复杂度**:$O(1)$,只使用了常数级的额外空间。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值