python找到相交链表的相交节点元素

最新推荐文章于 2025-05-27 13:04:31 发布
原创 最新推荐文章于 2025-05-27 13:04:31 发布 · 743 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#python3 #Leetcode #相交链表

该博客介绍了如何使用Python解决寻找两个单链表相交节点的问题，通过三种方法实现：找到长度差、指针追逐和使用集合。文章提供示例代码并分析了不同方法的时间复杂度。

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

相交链表

问题说明

编写一个程序，找到两个单链表相交的起始节点。
示例 1：

输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出：Reference of the node with value = 8
输入解释：相交节点的值为 8 （注意，如果两个列表相交则不能为 0）。从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。
示例 2：

输入：intersectVal = 2, listA = [0,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
输出：Reference of the node with value = 2
输入解释：相交节点的值为 2 （注意，如果两个列表相交则不能为 0）。从各自的表头开始算起，链表 A 为 [0,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。

注意：
如果两个链表没有交点，返回 null.
在返回结果后，两个链表仍须保持原有的结构。
可假定整个链表结构中没有循环。
程序尽量满足 O(n) 时间复杂度，且仅用 O(1) 内存。

思路与注意

官方文档描述is为对象标示符（object identity），而==表示的是相等。is的作用是用来检查对象的标示符是否一致，也就是两个对象在内存中的位置是否一样，而==是用来检查两个对象是否相等
因为是找到相同的元素（id相同）所以之前的比较我用的是 is 而不是 ==
但这里可以用 ==，和id结果一样。

参考Leetcode中的答案：

  1. 找到长度差
  2. 指针追逐
  3. 使用集合

找到长度差

class Solution():
    def getIntersectionNode(self, headA, headB):
        """

        :param headA: ListNode
        :param headB: ListNode
        :return: ListNode
        """
        a = b = 0
        h1 = headA
        h2 = headB
        while h1:
            h1 = h1.next
            a +=1
        while h2:
            h2 = h2.next
            b +=1
        h1 = headA
        h2 = headB
        if a >= b:
            for i in range(a - b):
                h1 = h1.next
        else:
            for i in range(b - a):
                h2 = h2.next
        while h1 and h2:
            if h1 is h2:
                break
            h1 = h1.next
            h2 = h2.next
        return h1

指针追逐

class Solution(object):
    def getIntersectionNode(self, headA, headB):
        """
        将两个链表拼接在一起，p是headA->headB
        q是headB->headA
        这样p和q的长度一致，会在相交节点相遇
        要么就都返回None
        :param headA: ListNode
        :param headB: ListNode
        :return: ListNode
        """
        p = headA
        q = headB
        # p 4,1,8,4,5->5,0,1,8,4,5
        # q 5,0,1,8,4,5->4,1,8,4,5

        while p is not q:
            p = p.next if p else headB
            q = q.next if q else headA
        return p

使用集合

class Solution():
    def getIntersectionNode(self, headA, headB):
        """

        :param headA: ListNode
        :param headB: ListNode
        :return: ListNode
        """
        s = set()
        h1 = headA
        h2 = headB
        while h1:
            s.add(h1)
            h1 = h1.next
        while h2:
            if h2 in s:
                break
            h2 = h2.next
        return h2

总结

上面三种方法的时间复杂度逐渐降低

三种方法的耗时，第一个是 使用集合 第二个是 使用距离差 第三个是指针追逐

可供测试用的源代码

"""
160. 相交链表

编写一个程序，找到两个单链表相交的起始节点。
示例 1：

输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出：Reference of the node with value = 8
输入解释：相交节点的值为 8 （注意，如果两个列表相交则不能为 0）。从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。
示例 2：

输入：intersectVal = 2, listA = [0,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
输出：Reference of the node with value = 2
输入解释：相交节点的值为 2 （注意，如果两个列表相交则不能为 0）。从各自的表头开始算起，链表 A 为 [0,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。

注意：
    如果两个链表没有交点，返回 null.
    在返回结果后，两个链表仍须保持原有的结构。
    可假定整个链表结构中没有循环。
    程序尽量满足 O(n) 时间复杂度，且仅用 O(1) 内存。

"""
# Definition for singly-linked list.
class ListNode:
    def __init__(self, x):
        self.val = x
        self.next = None
## 指针追逐
class Solution(object):
    def getIntersectionNode(self, headA, headB):
        """
        将两个链表拼接在一起，p是headA->headB
        q是headB->headA
        这样p和q的长度一致，会在相交节点相遇
        要么就都返回None
        :param headA: ListNode
        :param headB: ListNode
        :return: ListNode
        """
        p = headA
        q = headB
        # p 4,1,8,4,5->5,0,1,8,4,5
        # q 5,0,1,8,4,5->4,1,8,4,5

        while p is not q:
            p = p.next if p else headB
            q = q.next if q else headA
        return p
## 因为是找到相同的元素（id相同）所以之前的比较我用的是 is 而不是 ==
## 但这里可以用 ==
# 官方文档描述is为对象标示符（object identity），而==表示的是相等。is的作用是用来检查对象的标示符是否一致，也就是两个对象在内存中的位置是否一样，而==是用来检查两个对象是否相等。


## 用集合set
# class Solution():
#     def getIntersectionNode(self, headA, headB):
#         """
#
#         :param headA: ListNode
#         :param headB: ListNode
#         :return: ListNode
#         """
#         s = set()
#         h1 = headA
#         h2 = headB
#         while h1:
#             s.add(h1)
#             h1 = h1.next
#         while h2:
#             if h2 in s:
#                 break
#             h2 = h2.next
#         return h2

## 距离，容易想到
# class Solution():
#     def getIntersectionNode(self, headA, headB):
#         """
#
#         :param headA: ListNode
#         :param headB: ListNode
#         :return: ListNode
#         """
#         a = b = 0
#         h1 = headA
#         h2 = headB
#         while h1:
#             h1 = h1.next
#             a +=1
#         while h2:
#             h2 = h2.next
#             b +=1
#         h1 = headA
#         h2 = headB
#         if a >= b:
#             for i in range(a - b):
#                 h1 = h1.next
#         else:
#             for i in range(b - a):
#                 h2 = h2.next
#         while h1 and h2:
#             if h1 is h2:
#                 break
#             h1 = h1.next
#             h2 = h2.next
#         return h1


def stringToInt(input):
    return int(input)

def stringToListNode(intersectVal, listA, listB, skipA, skipB):
    # Generate list from the input

    # Now convert that list into linked list
    """

    :param intersectVal: int    intersection node (0 means no intersection between A and B)
    :param listA: list          contains the value of a singly-linked list A
    :param listB: list          contains the value of a singly-linked list B
    :param skipA: int           the number of nodes [start node, intersection node) in A
    :param skipB: int           the number of nodes [start node, intersection node) in B
    :return: tuple              contains two singly-linked lists
    """
    dummyRoot1 = ListNode(0)
    ptr1 = dummyRoot1

    dummyRoot2 = ListNode(0)
    ptr2 = dummyRoot2

    # d1 = (dummyRoot1==dummyRoot2)
    # d2 = dummyRoot1 is dummyRoot2
    a = b = 0

    for number in listA:
        ptr1.next = ListNode(number)
        ptr1 = ptr1.next
        a += 1
        if a == skipA:
            break
    for number in listB:
        ptr2.next = ListNode(number)
        ptr2 = ptr2.next
        b += 1
        if b == skipB:
            break
    intersec = ptr1
    if intersectVal == 0:
        for i in range(a, len(listA)):
            ptr1.next = ListNode(listA[i])
            ptr1 = ptr1.next
        for i in range(b, len(listB)):
            ptr2.next = ListNode(listB[i])
            ptr2 = ptr2.next
    else:
        for i in range(a, len(listA)):
            ptr1.next = ptr2.next = ListNode(listA[i])
            ptr1, ptr2 = ptr1.next, ptr2.next

    return dummyRoot1.next, dummyRoot2.next, intersec.next

def listNodeToString(node):
    if not node:
        return "[]"

    result = ""
    while node:
        result += str(node.val) + ", "
        node = node.next
    return "[" + result[:-2] + "]"

def main():
    line1 = 8
    intersectVal = stringToInt(line1)

    listA = [4,1,8,4,5]
    listB = [5,0,1,8,4,5]

    line3 = 2
    skipA = stringToInt(line3)
    line4 = 3
    skipB = stringToInt(line4)

    headA, headB, intersec =stringToListNode(intersectVal, listA, listB, skipA, skipB)

    ret = Solution().getIntersectionNode(headA, headB)

    out = listNodeToString(ret)

    if intersectVal>0 and ret is intersec:
        print("Intersected at \'%d\'" % intersectVal)
    elif intersectVal==0 and not ret:
        print("No intersection")
    else:
        print("Wrong output")
    print(out)


if __name__ == '__main__':
    main()
求两个链表的第一个公共节点
qq_38158479的博客
05-02 291
链表A：1->2->3->6->7 链表B：4->5->6->7 第一个公共节点：6 #include "pch.h" #include<iostream> #include<stack> using namespace std; struct NODE { int m_value; struct NODE *next; }; /* *创建头结点 */ NODE* Linklist_init(void) { NODE *p = ne
【算法-链表-python】相交链表
热门推荐
优快云站内信: https://i.youkuaiyun.com/#/msg/chat/qyj19920704
07-09 2万+
的输入如下（你设计的程序。
算法题5 找出两个链表的第一个公共结点
在水一方
05-17 2万+
题目：两个单向链表，找出它们的第一个公共结点。 链表的结点定义为： struct ListNode {       int       m_nKey;       ListNode*   m_pNext; }; 分析：这是一道微软的面试题。微软非常喜欢与链表相关的题目，因此在微软的面试题中，链表出现的概率相当高。 如果两个单向链表有公共的结点，也就是说两个链表从某一结点开始，它们的
相交链表 #python解法
最新发布
weixin_54113539的博客
05-27 321
摘要：该算法通过双指针遍历两个链表寻找相交节点。当指针到达链表末尾时，切换到另一链表开头继续遍历。若两指针相遇则返回相交节点，否则当两指针同时到达各自链表末尾时返回None。关键点在于利用指针遍历两链表的长度差，使其在相交节点处对齐。
链表中的公共节点
zhangchuan的博客
08-25 2862
求取来拿表中的第一个公共节点。 由于链表中的节点都有一个指向下一个节点的指针，当某个节点公共时，意味着该公共节点指向的下一个节点也公共，即第一个公共节点后的所有节点公共。因此，两条链表按公共节点重叠后呈现Y型。 我们可以先计算两条链表的长度差，该长度差就是长链表优先要走的步数，之后两链表就一个一个对应比较，直到找到第一个公共节点为止。 具体代码如下: // ConsoleApplicati
给定两个单链表，找出两个链表的公共节点
xiao9t98的博客
01-12 1309
思路 若两个单链表有公共节点，那么这两个单链表从第一个公共节点开始，之后的所有节点均为公共节点。 若两个链表一样长，则直接从头向后同步遍历，第一个相同节点开始即为公共部分； 若两个链表不一样长，先把两者长度搞一样，再遍历 NodeList Search_common(NodeList L1, NodeList L2) { int len1 = Length(L1), len2 = Length(L2); int distance = 0; NodeList longList, shortList;
输入两个链表，找出它们的第一个公共结点
LIMorton的博客
03-13 1398
问题：输入两个链表，找出它们的第一个公共结点。     分析：第一反应是蛮力法，这是没认真思考才想到的方法。仔细分析就会发现，这两个链表有着共同的尾部，在两个链表达到第一个公共结点后，之后每个结点都是相同的，拓扑形状呈现为Y型结构。     思路一：首先遍历两个链表，得到两个链表的长度，并得到两个链表的长度差。然后进行第二次遍历，首先在更长的哪一条链表上先走那个长度差的步数（可能长度差为零，一
no.160 相交链表 python
White__Sun的博客
10-15 250
给你两个单链表的头节点headA和headB，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回null。
python 相交链表
田亚辉的博客
11-28 488
｜相交链表 给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回 null 。 图示两个链表在节点 c1 开始相交： 题目数据 保证 整个链式结构中不存在环。 注意，函数返回结果后，链表必须 保持其原始结构 。 自定义评测： 评测系统 的输入如下（你设计的程序 不适用 此输入）： intersectVal - 相交的起始节点的值。如果不存在相交节点，这一值为 0 listA - 第一个链表 listB - 第二个链表 skipA -
Python算法题集_相交链表
长孤秋落的札记
02-04 1006
题目41：相交链表：给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回 null
python-leetcode面试题解之第160题相交链表-题解.zip
05-21
你的任务是找到这个相交节点，如果没有相交，则返回null。题目中强调，两个链表的长度不一，但它们的交点不会是它们的头结点。 在Python中，链表通常用类来表示，每个节点包含数据和指向下一个节点的指针。我们首先...
相交链表（python练习）
加油加油！！！
07-17 871
python算法练习——相交链表
两个链表的公共节点
面向搜素引擎编程
09-11 3091
思路1 使用栈 从链表结点的定义可以看出，这两个链表是单链表。如果两个单向链表有公共的结点，那么这两个链表从某一结点开始，它们的m_pNext都指向同一个结点，但由于是单向链表的结点，之后他们所有结点都是重合的，不可能再出现分叉。所以两个有公共结点而部分重合的链表，拓扑形状开起来像一个Y，而不可能项X。 如果两个链表有公共结点，那么公共结点出现在两个链表的尾部。如果我们从两个链表...
python练习：两个链表的第一个公共结点
薰衣草PK向日葵的博客
07-30 1306
题目 输入两个链表，找出它们的第一个公共结点。 分析 对于公共结点，解释应该是：如果两个单向链表存在公共节点，那么从第一个公共节点开始到最后一个节点都是公共节点。也就是说，相同的点，不仅值相同，后继节点也相同，那么同理公共结点后面的点也是不仅值相同，而且后继节点也相同。这样的话，就可以把两条链条看成Y字型了，某一个结点后面的点全部一样。 例如下图中，链表 6 - 7 就是两个链表的公共链表，而节点6就是第一个公共节点。 方法一 最直观的当然就是暴力法——双重循环。 那么在第一链表上顺序遍历
两个链表的第一个公共结点（Java）
Sweet Baby，甜宝
08-24 1182
题目： 输入两个链表，找出它们的第一个公共结点。链表结点的定义如下： struct ListNode{ int m_nKey; ListNode* m_pNext; } 思路： 第一种解法：蛮力（暴力）法。 第二种解法：借助于栈的先进后出，由于找到两个链表的第一个公共结点，故这个链表在公共结点以后是一个Y字型，故我们将两个链表放入栈中，来找到栈中最后一个相同的结点，即为...
求俩个链表的相交结点
qq_43632625的博客
10-26 410
编写一个程序，找到两个单链表相交的起始节点。
两个单向链表，找出它们的第一个公共结点
void* jngxiao(void* life)
09-07 902
题目：两个单向链表，找出它们的第一个公共结点。链表的结点定义为：struct ListNode{     int         m_nKey;     ListNode*   m_pNext;};分析：这是一道微软的面试题。微软非常喜欢与链表相关的题目，因此在微软的面试
21. 寻找两个链表的第一个公共节点
sunnnnh的博客
05-07 300
一、题目 输入两个链表，找出它们的第一个公共节点。 二、实现 对于A和B两个链表（长度分别为lenA和lenB，公共长度为lenAB），a和b分别指向链表A和B的第一个结点 a先遍历链表A，然后再遍历链表B，直到与b相遇 （遍历的长度：A的长度lenA + 与b相遇前已遍历的链表B的长度lenB-lenAB） b先遍历链表B，然后再遍历链表A，直到与a相遇 （遍历的长度：B的长度lenB + 与a相遇前已遍历的链表A的长度lenA-lenAB） 即a和b都遍历了链表A和B的结点 a和b相.
python相交链表
02-23
### Python 实现相交链表算法 #### 定义链表节点类 为了实现相交链表的检测功能，首先定义一个简单的单向链表节点 `ListNode` 类。 ```python class ListNode: def __init__(self, x): self.val = x self.next = None ``` #### 方法一：标准求解（双层循环） 这种方法通过遍历第一个链表并将所有访问过的节点存储起来，再依次检查第二个链表中的每一个节点是否存在于之前保存的结果集中。时间复杂度较高，为 O(n*m)，其中 n 和 m 分别代表两个链表的长度[^1]。 #### 方法二：改进版一（双指针法） 此方法利用了两个指针分别指向两条链表头部并同步前进的特点，在到达各自末端后转向另一条链表继续移动直到相遇为止。这样做的好处是可以平衡掉两者的长度差异从而找到交叉点。该方案的时间复杂度降低到了O(n+m)。 ```python def getIntersectionNode(headA: ListNode, headB: ListNode) -> ListNode: pointerA, pointerB = headA, headB while pointerA is not pointerB: pointerA = headB if pointerA is None else pointerA.next pointerB = headA if pointerB is None else pointerB.next return pointerA # Either the intersection node or both reached end(None) ``` #### 方法三：改进版二（哈希检索-集合） 使用Python内置的数据结构——set来记录已经访问过的第一条链表上的结点地址信息，之后再次遍历第二条链表查看是否有相同位置的对象存在即可快速定位交汇处。这种方式的空间消耗较大但是效率很高，平均情况下可以在接近线性时间内解决问题[^2]。 ```python def getIntersectionNode_with_set(headA: ListNode, headB: ListNode) -> ListNode: visited_nodes = set() current_node = headA while current_node: visited_nodes.add(current_node) current_node = current_node.next current_node = headB while current_node: if current_node in visited_nodes: return current_node current_node = current_node.next return None ``` #### 方法四：最优算法分析 综合考虑时间和空间性能因素，上述三种方式各有优劣。对于实际应用而言，“双指针”策略通常被认为是最优的选择因为它既保持了一定程度上的高效又能较好地控制额外内存开销。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值