LeetCode第160题—相交链表—Python实现

Posted StriveZs

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了LeetCode第160题—相交链表—Python实现相关的知识,希望对你有一定的参考价值。


title: LeetCode No.160

categories:

  • OJ
  • LeetCode

tags:

  • Programing
  • LeetCode
  • OJ

LeetCode第160题—相交链表

自己代码的开源仓库:click here 欢迎Star和Fork 😃

题目描述

我真的菜死了QAQ,这道题写了半个多小时才写出来,一道简单题 我气哦。因为没有plus会员,我还是老实的刷免费的吧。

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

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

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

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

示例 1:

输入:intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出:Intersected at '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
输出:Intersected at '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 。
 

提示:

listA 中节点数目为 m
listB 中节点数目为 n
0 <= m, n <= 3 * 104
1 <= Node.val <= 105
0 <= skipA <= m
0 <= skipB <= n
如果 listA 和 listB 没有交点,intersectVal 为 0
如果 listA 和 listB 有交点,intersectVal == listA[skipA + 1] == listB[skipB + 1]

代码

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution(object):
    def timeout(self, headA, headB):
        """
        考虑用list分别分出两个head出现的节点, 然后遍历就好了 直到有首个重复的节点结束
        :type head1, head1: ListNode
        :rtype: ListNode
        """
        listA = [] # 专门存储A的节点
        listB = [] # 专门存储B的节点
        while headA != None or headB != None:
            listA.append(headA)
            listB.append(headB)
            if headB in listA:
                return headB
            if headA in listB:
                return headA
            if headA != None:
                headA = headA.next
            if headB != None:
                headB = headB.next
        return None
    def getIntersectionNode(self, headA, headB):
        """
        参考了一下大佬的思路,由于两个链表长度不相同,但是可以使用另外一种办法让他们的长度变得一样长
        让两个head同时出发,如果其中一个head走到头了,则开始走另一个head的路,这样两条路长度就一样了,就会在同一个点相同,有点类似莫比乌斯环的感觉后面给图示
        :type head1, head1: ListNode
        :rtype: ListNode
        """
        if headA is None or headB is None:
            return None
        # 开始走
        h1 = headA
        h2 = headB
        flag1 = True
        flag2 = True
        while h1 != h2:
            if h1 is not None:
                if h1.next is not None:
                    h1 = h1.next
                else:
                    if flag1:
                        h1 = headB
                        flag1 = False
                    else:
                        h1 = None
            if h2 is not None:
                if h2.next is not None:
                    h2 = h2.next
                else:
                    if flag2:
                        h2 = headA
                        flag2 = False
                    else:
                        h2 = None
        return h1

以上是关于LeetCode第160题—相交链表—Python实现的主要内容,如果未能解决你的问题,请参考以下文章

精选力扣500题 第8题 LeetCode 160. 相交链表 c++详细题解

LeetCode Java刷题笔记—160. 相交链表

Leetcode刷题笔记之链表篇160. 相交链表

Leetcode刷题笔记之链表篇160. 相交链表

[ 链表OJ题--C语言] 相交链表 两个链表的第一个公共结点

LeetCode题解160_相交链表