48 两个链表的交叉(Intersection of Two Linked Lists)

本文详细介绍了如何解决寻找两个链表交叉节点的问题。通过将一个链表的尾部连接到头部,构造出带环链表,再利用快慢指针寻找环的起点来找到交点。这种方法的时间复杂度为O(n),空间复杂度为O(1)。此外,还给出了C++实现的源码示例。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

1 题目

题目:两个链表的交叉(Intersection of Two Linked Lists)
描述:请写一个程序,找到两个单链表最开始的交叉节点。

  1. 如果两个链表没有交叉,返回null。
  2. 在返回结果后,两个链表仍须保持原有的结构。
  3. 可假定整个链表结构中没有循环。

lintcode题号——380,难度——medium

样例1:

输入:
	A:          a1 → a2
	                   ↘
	                     c1 → c2 → c3
	                   ↗            
	B:     b1 → b2 → b3
输出:c1
解释:在节点 c1 开始交叉。

样例2:

输入:
Intersected at 6
1->2->3->4->5->6->7->8->9->10->11->12->13->null
6->7->8->9->10->11->12->13->null
输出: Intersected at 6
解释:begin to intersect at node 6.

2 解决方案

2.1 思路

  找链表交点的问题,可以将两个链表构造成一个带环链表,这样就可以参考寻找带环链表中的环的起点的做法,本题将任意一个链表的尾部连接到链表头,就能构造出一个带环的链表了。

2.2 图解

两个相交的链表:

a1
a2
c1
c2
c3
b1
b2
b3

将其中一个首尾相连,就可以构成一个大的带环链表:

a1
a2
c1
c2
c3
b1
b2
b3

2.3 时间复杂度

  若两个链表的长度分别为m和n,时间复杂度为O(n)。

2.4 空间复杂度

  空间复杂度为O(1)。

3 源码

细节:

  1. 连接其中一个链表a的首尾,形成环,将两个链表构成一整个链表,新链表的表头是链表b的表头。
  2. 按照寻找带环链表中的环的起点位置的做法,

C++版本:

/**
* Definition of singly-linked-list:
* class ListNode {
* public:
*     int val;
*     ListNode *next;
*     ListNode(int val) {
*        this->val = val;
*        this->next = NULL;
*     }
* }
*/
/**
* @param headA: the first list
* @param headB: the second list
* @return: a ListNode
*/
ListNode * getIntersectionNode(ListNode * headA, ListNode * headB) {
    // write your code here
    if (headA == nullptr || headB == nullptr)
    {
        return nullptr;
    }

    // 找到B链表的尾部
    ListNode * cur = headB;
    while (cur->next != nullptr)
    {
        cur = cur->next;
    }
    cur->next = headB; // 将B链表尾部连接到其头部形成环

    // 在AB链表形成的链表环里寻找交点
    ListNode * slow = headA;
    ListNode * fast = headA;
    while (fast != nullptr && fast->next != nullptr)
    {
        slow = slow->next;
        fast = fast->next->next;

        if (slow == fast) // 找到环,slow记录了快慢指针相遇的位置
        {
            ListNode * index = headA; // 新建一个从头开始的指针
            while (index != slow) // index与slow同时前进,相遇的时候就是链表环的起点
            {
                index = index->next;
                slow = slow->next;
            }

            cur->next = nullptr; // 将链表B复原
            return index;
        }
    }

    return nullptr; // 如果无环,则返回空
}
为了计算两个链表表示的集合A和B之间的交集,我们首先需要理解链表的基本结构以及如何遍历它。这里假设每个节点包含单个值,并且这两个链表没有重复元素。 下面是一个简单的Python算法,用于找出给定两个链表所代表的集合的交集: ```python class ListNode: def __init__(self, value=0, next=None): self.value = value self.next = next def linked_list_to_set(head): """将链表转换成集合""" elements = set() current_node = head while current_node is not None: elements.add(current_node.value) current_node = current_node.next return elements def intersection_of_lists(list_a_head, list_b_head): """找到两个链表作为集合相交的部分""" # 将两个链表转化为集合 set_A = linked_list_to_set(list_a_head) set_B = linked_list_to_set(list_b_head) # 计算两个集合的交集 intersected_elements = set_A.intersection(set_B) # 如果需要返回结果为一个新的链表形式可以这么做: dummy_head = ListNode() # 创建哑结点 tail = dummy_head # 维护新链表最后一个位置指针 for elem in intersected_elements: new_node = ListNode(elem) tail.next = new_node tail = new_node return dummy_head.next if dummy_head.next else None # 返回非空部分 # 示例用法: node_1 = ListNode(1) node_2 = ListNode(2) node_3 = ListNode(3) node_4 = ListNode(4) node_5 = ListNode(5) list_a = node_1 node_1.next = node_2 node_2.next = node_3 list_b = node_4 node_4.next = node_2 # 注意此处引用了相同的Node对象以模拟交集情况 node_2.next = node_5 intersected_list = intersection_of_lists(list_a, list_b) current = intersected_list while current: print(current.value) current = current.next ``` 此段代码实现了以下功能: - 定义了一个`ListNode`类,用于创建链表节点。 - `linked_list_to_set()`函数接收一个链表头并将其所有元素添加到一个set中去除重复项。 - `intersection_of_lists()`接受两个链表头部作为输入参数,然后通过上述辅助函数把它们变成sets之后再求其交集。最后按照需求选择是否构造出新的只含交集中成员的新链表
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值