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
算法题5 找出两个链表的第一个公共结点
热门推荐
在水一方
05-17 2万+
题目：两个单向链表，找出它们的第一个公共结点。 链表的结点定义为： struct ListNode {       int       m_nKey;       ListNode*   m_pNext; }; 分析：这是一道微软的面试题。微软非常喜欢与链表相关的题目，因此在微软的面试题中，链表出现的概率相当高。 如果两个单向链表有公共的结点，也就是说两个链表从某一结点开始，它们的
两个单向链表，找出它们的第一个公共结点
void* jngxiao(void* life)
09-07 902
题目：两个单向链表，找出它们的第一个公共结点。链表的结点定义为：struct ListNode{     int         m_nKey;     ListNode*   m_pNext;};分析：这是一道微软的面试题。微软非常喜欢与链表相关的题目，因此在微软的面试
相交链表 #python解法
最新发布
weixin_54113539的博客
05-27 321
摘要：该算法通过双指针遍历两个链表寻找相交节点。当指针到达链表末尾时，切换到另一链表开头继续遍历。若两指针相遇则返回相交节点，否则当两指针同时到达各自链表末尾时返回None。关键点在于利用指针遍历两链表的长度差，使其在相交节点处对齐。
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相.
剑指offer-36 -- 两个链表的第一个公共结点 - C++
小白_努力
10-23 253
题目描述 输入两个链表，找出它们的第一个公共结点。（注意因为传入数据是链表，所以错误测试数据的提示是用其他方式显示的，保证传入数据是正确的） 方法：双指针法 假如例子如下： 显然第一个公共结点为8，但是链表A头结点到8的长度为2，链表B头结点到8的长度为3，显然不好办？ 如果我们能够制造一种理想情况，如下： 这里先假设链表A头结点与结点8的长度 与 链表B头结点与结点8的长度相等，那么就可以用双指针。 初始化：指针ta指向链表A头结点，指针tb指向链表B头结点 如果ta == tb，
【leetcode-python】剑指 Offer 52. 两个链表的第一个公共节点
hbk5241的博客
01-28 140
输入两个链表，找出它们的第一个公共节点。 如下面的两个链表： 在节点 c1 开始相交。 示例 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
输入两个链表，找出它们的第一个公共结点
xxxxd_的博客
12-17 307
这是牛客剑指offer 36题，这道题总结了如下四种解法： 解法1是比较容易想到的一种，先分别求出长度，然后长的先走插值步，然后再同时走并判断是否相等，相等的结点即为所求。 解法2是在答案区看到的非常巧妙的方法(我当然是想不出来的????)，如果你打眼一瞅看不太明白可以画个图就明白了，十分巧妙的。 解法3利用栈先进后出的原则，先把两个链表都分别入栈，然后相同的结点都往外弹出，直到弹出不同的结点，那个结点的前一个结点即为所求。需要考虑如果弹出的第一个结点就不相等的话直接返回null，还有每次弹出前peek一下
输入两个链表，找出他们的第一个公共节点
weixin_33743880的博客
04-19 299
分析：如果两个单向链表有公共的结点，也就是说两个链表从某一结点开始，它们的m_pNext都指向同一个结点。但由于是单向链表的结点，每个结点只有一个m_pNext，因此从第一个公共结点开始，之后它们所有结点都是重合的，不可能再出现分叉。所以，两个有公共结点而部分重合的链表，拓扑形状看起来像一个Y，而不可能像X。 我们先把问题简化：如何判断两个单向链表有没有公共结点？前面已经提到，如果两个链表有一个...
寻找链表公共节点
龙思
06-05 1199
 两个链表，其中一个链表的末尾结点的next指针指向另一个链表的某一个结点。以最少的时空消耗量找到那个共同的结点  。两个一起遍历，当一个走完时，开始记那个还没走完的还要走多少步 设m步，那个比较长的链表先走m步，然后两个链表一起走，next相等的那个是公共节点
找到两个单向链表的第一个公共节点
CNnumen
08-01 1416
<br />两个单向链表，可能存在公共节点。如何判断是否存在公共节点，并找出它们的第一个公共结点。<br /> <br />思路:<br />如果两个单向链表有公共节点，则两个链表会构成Y型结构，最后一个节点相同。<br /><br />我们可以从头开始遍历两个链表，找到最后一个节点的指针，设为p_a，p_b。同时记录下两个链表的长度len_a，len_b（假设len_a >= len_b)。<br />如果p_a == p_b，则说明两个链表有公共节点，否则没有。<br />如果有公共节点，则第一个公共节
两个链表的第一个公共结点
如是说的博客
03-27 288
题目描述 输入两个链表，找出它们的第一个公共结点。 节点类： public class ListNode { int val; ListNode next = null; ListNode(int val) { this.val = val; } } 分析 首先要理解什么是公共节点，并不是两个节点的值相同就是公共节点。 而是在第一链表和第二链表中都存在一个节点，该节点往后的子链表在...
《剑指Offer》面试题：寻找两个链表的第一个公共节点
wojiushimogui的博客
10-07 887
题目 输入两个链表，找出它们的第一个公共结点。 思路 画图会发现如果二者有公共结点，则公共节点后面的节点也都是公共节点。用两个辅助栈，将两个链表从头分别压入栈，最后二者出栈，最后一个相同的出栈元素即为公共节点。 但以上这样需要开辟两个栈的空间，实际上，如果用两个数组来保存链表结点就可以不用开辟空间，分别求出二者的长度，求出二者的差dis， 而后将指向长的链表的指针
LeetCode | 160. 相交链表
橘嘉禾
03-20 229
编写一个程序，找到两个单链表相交的起始节点。 如下面的两个链表： 在节点 c1 开始相交。 示例 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 ...
算法-寻找两个链表的第一个公共结点
zhangxu
08-04 743
题目： 输入两个链表，找到他们的第一个公共结点，链表结点定义如下：struct ListNode { int value; ListNode *next; };解题思路： 首先我们需要想清楚的是，如果一个链表出现了公共结点，那么这两个链表是什么样子的，显然它的结构应该是一个“Y”型： 由于是单向链表，所以只有一个指向下一个结点的指针。这意味着如果出现了公共结点那么这个结点之后的结点也
找出两个链表的第一个公共结点
yanweiding的博客
10-29 109
public class Solution { public ListNode getIntersectionNode(ListNode headA, ListNode headB) { if(headA==null||headB==null){ return null; } ListNode pl =headA; ListNode ps=headB; int len1=0; while(pl!=null)
程序员面试题精选——找出两个链表的第一个公共节点
05-25 3987
问题描述：给定两个单向链表，找出它们的第一个公共节点。
题目：输入两个链表，找出它们的第一个公共结点
岩枭的博客
08-05 7132
题目：输入两个链表，找出它们的第一个公共结点。链表的定义如下： struct ListNode {      int m_nValue;      ListNode* m_pNext; };       看到这道题的时候，很多人的第一反应就是采用蛮力的方法：在第一个链表上顺序遍历每个节点，每遍历到一个节点的时候，在第二个链表上顺序遍历每个节点。如果第二个链表上的节点和第一个链表
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、付费专栏及课程。

余额充值