七、链表问题(上)

160、相交链表(简单)

题目描述

给你两个单链表的头节点 headAheadB ,请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点,返回 null

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

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

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

示例1:

示例2:

示例3:

提示:

  • listA 中节点数目为 m
  • listB 中节点数目为 n
  • 1 <= m, n <= 3 * 104
  • 1 <= Node.val <= 105

题目思路

对于这道题,是非常经典的链表类型的题目,要求获得两个链表交叉的位置(如果不交叉返回为空)。

需要注意的是,两个单链表的交叉,并不是像 “染色体” 那种X形式的交叉,因为一个单链表节点只能有一个后继(next),因此,只要交叉,就相当于二者汇融在了一起。

首先最直接的方法,是先获得两个链表的长度,然后让其中一个长度长的先走(len_a - len_b)的距离,最后,二者指针再一起走,就可以获得相交叉的节点了。

同时还有第二种不需要计算链表长度的方法:

  • 创建指针 ab ,分别指向headAheadB
  • 每步操作同时更新 ab
    • 如果指针 a 不为空,则将指针 a 移到下一个节点;如果指针 b 不为空,则将指针 b 移到下一个节点;
    • 如果指针 a 为空,则将指针 a 移到链表 headB 的头节点;如果指针 b 为空,则将指针 b 移到链表 headA 的头节点;
  • 当指针 ab 指向同一个节点或者都为空时,返回它们指向的节点或者 None

    通过两个指针,第一轮让二者到达末尾的节点然后指向对方的头部,这样就相当于是抹除了距离差。
    第二轮的行走,如果有交点,这二者一定会相交,否则二者会一同走到结尾的None

算法代码

1、计算链表长度

class Solution:
    def getListLength(self, head):
        res = 0
        while head:
            res += 1
            head = head.next
        return res

    def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:
        if headA is None or headB is None:
            return None

        len_a, len_b = self.getListLength(headA), self.getListLength(headB)

        if len_a >= len_b:
            gap = len_a - len_b
            while gap > 0:
                headA = headA.next
                gap -= 1
        else:
            gap = len_b - len_a
            while gap > 0:
                headB =headB.next
                gap -= 1

        while headA != headB:
            headA = headA.next
            headB = headB.next

        return headA

2、双指针法

class Solution:
    def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:
        if headA is None or headB is None:
            return None

        a, b = headA, headB
        while a != b:
            a = a.next if a else headB
            b = b.next if b else headA
        
        return a

206、反转链表(简单)

题目描述

给你单链表的头节点 head ,请你反转链表,并返回反转后的链表。
示例1:

示例2:

提示:

  • 链表中节点的数目范围是 [0, 5000]
  • -5000 <= Node.val <= 5000

题目思路

对于这道题,也是链表问题中较为经典的类型——翻转。
题目的标准解法,就是通过定义一个prev节点来记录链表翻转后应当指向的节点:

  • 记录当前节点head的下一个节点next(因为一旦翻转而不记录,原始next将会丢失)
  • head节点指向所记录的上一个节点prev
  • prev节点指向当前的head节点,作为下一轮循环的上一个节点;
  • head节点指向第一步记录的next节点,作为下一轮循环的当前节点;

算法代码

class Solution:
    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
        prev_node = None
        
        while head:
            next_node = head.next
            head.next = prev_node
            prev_node = head
            head = next_node

        return prev_node

234、回文链表(简单)

题目描述

给你一个单链表的头节点 head ,请你判断该链表是否为回文链表。如果是,返回 true ;否则,返回 false

示例1:

输入:head = [1,2,2,1]
输出:true

示例 2:

输入:head = [1,2]
输出:false

提示:

  • 链表中节点数目在范围[1, 105] 内
  • 0 <= Node.val <= 9

进阶:
你能否用 O(n) 时间复杂度和 O(1) 空间复杂度解决此题?

题目思路

对于这道题,要求我们判断一个链表是否构成回文形式。
所谓回文,就是指1, 2, 2, 1这种形式,对于字符串或者数组而言,判断是否是回文相对简单,直接从两端向中间遍历即可。

但是在这道题中,所给定的数据结构为单链表,这就让直接比那
这里我们有两种思路:

1、辅助数组
直接定义一个数组,并在遍历链表的过程中将链其转化为数组、判断回文。
这种方法虽然简答, 但需要额外开辟O(n)的空间。

2、快慢指针+翻转链表

  • 利用快慢指针法,找到链表中间位置;
  • 对后半段链表进行翻转,然后分别从原链表head与翻转后后半段链表头遍历、判断是否相等即可;

在这种方法中,不需要额外的列表进行存储,但有几点需要注意:

  • 快慢指针法找中间位置时,链表节点个数偶数还是奇数需要单独判断:
    • 对于奇数个节点的情况,slow还需再向后一位越过中位线;
  • 后半段链表翻转后,注意前半段最后一个节点指向的还是后半段当前第一个节点,以此要以后半段作为遍历和判空条件;

算法代码

1、辅助数组

	class Solution:
    def isPalindrome(self, head: Optional[ListNode]) -> bool:
        if head.next is None:
            return True
        
        list_val = []
        while head:
            list_val.append(head.val)
            head = head.next

        n = len(list_val)
        for i in range(0, int(n/2)):
            if list_val[i] != list_val[n-1-i]:
                return False

        return True

2、快慢指针+翻转链表

	class Solution:
    def isPalindrome(self, head: Optional[ListNode]) -> bool:
        slow, fast = head, head

        # 使用快慢指针法找到链表中间位置
        # 注意链表节点个数偶数还是奇数需要单独判断
        while fast and fast.next:
            slow = slow.next
            fast = fast.next.next

        # 对于奇数个节点的情况,slow还需再向后一位越过中位线
        if fast:
            slow = slow.next

        # fast指向head,slow翻转,就可以通过直接比较的方法实现链表回文判断
        fast = head
        slow = self._reverse_list(slow)

        # 这里注意需要使用slow作为判断标准
        # 因为后半部分翻转不意味着前半部分末尾指向None
        while slow:
            if slow.val != fast.val:
                return False
            slow = slow.next
            fast = fast.next
        return True

    def _reverse_list(self, head):
        prev_node = None
        while head:
            next_node = head.next
            head.next = prev_node
            prev_node = head
            head = next_node
        return prev_node

141、环形链表(简单)

题目描述

给你一个链表的头节点 head ,判断链表中是否有环。

如果链表中有某个节点,可以通过连续跟踪 next 指针再次到达,则链表中存在环。 为了表示给定链表中的环,评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置(索引从 0 开始)。注意:pos 不作为参数进行传递 。仅仅是为了标识链表的实际情况。

如果链表中存在环 ,则返回 true 。 否则,返回 false

实例1:

输入:head = [3,2,0,-4], pos = 1
输出:true
解释:链表中有一个环,其尾部连接到第二个节点。

实例2:

输入:head = [1,2], pos = 0
输出:true
解释:链表中有一个环,其尾部连接到第一个节点。

实例3:

输入:head = [1], pos = -1
输出:false
解释:链表中没有环。

提示:

  • 链表中节点的数目范围是 [0, 104]
  • -105 <= Node.val <= 105
  • pos 为 -1 或者链表中的一个 有效索引 。

进阶:
你能用 O(1)(即,常量)内存解决此问题吗?

题目思路

对于这道题,是链表类问题中较为典型的一种,需要我们判断一个链表中是否有环。

对于这类判断链表是否有环问题,我们一般使用快慢指针法,即定义两个指针,一个为slow,一个为fast,从头开始对链表进行扫描:

  • 指针slow每次走一步,指针fast每次走两步
  • 如果存在环,则这两个指针一定会相遇
  • 如果不存在环,则fast指针会最先到达NULL而退出。

为何说二者一定相遇?
因为fast会先进入环,在slow进入之后,如果把slow看做在前面,则fast在后面每次循环都会想slow靠近1,所以一定会相遇,而不会出现fast直接跳过slow的情况。

而另一类解法,则是直接对链表值做修改特殊值
如果我们遍历了一个节点,那么我们就将其的值修改为特殊的——比如无穷大INF,这样我们一直遍历下去,如果再次找到了这样的值为INF的节点,那么我们就可以认为这个链表是有环的。

算法代码

1、快慢指针法

class Solution:
    def hasCycle(self, head: Optional[ListNode]) -> bool:
        slow, fast = head, head
        while fast and fast.next:
            slow = slow.next
            fast = fast.next.next
            if slow == fast:
                return True
        return False

2、修改链表值

class Solution:
    def hasCycle(self, head: ListNode) -> bool:
        INF = float('inf')
        while head != None:
            if head.val != INF:
                head.val = INF
                head = head.next
            else:
                return True
        return False

142、环形链表 II(中等)

题目描述

给定一个链表的头节点 head ,返回链表开始入环的第一个节点。 如果链表无环,则返回 null

如果链表中有某个节点,可以通过连续跟踪 next 指针再次到达,则链表中存在环。 为了表示给定链表中的环,评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置(索引从 0 开始)。如果 pos-1,则在该链表中没有环。注意:pos 不作为参数进行传递,仅仅是为了标识链表的实际情况。

不允许修改 链表。

示例 1:

输入:head = [3,2,0,-4], pos = 1
输出:返回索引为 1 的链表节点
解释:链表中有一个环,其尾部连接到第二个节点。

示例 2:

输入:head = [1,2], pos = 0
输出:返回索引为 0 的链表节点
解释:链表中有一个环,其尾部连接到第一个节点。

示例3:

输入:head = [1], pos = -1
输出:返回 null
解释:链表中没有环。

提示:

  • 链表中节点的数目范围在范围 [0, 104] 内
  • -105 <= Node.val <= 105
  • pos 的值为 -1 或者链表中的一个有效索引

进阶:

  • 你是否可以使用 O(1) 空间解决此题?

题目思路

对于这道题,是在上一个判断链表是否有环的基础上更进一步、找到链表开始入环的第一个节点。

这里,我们同样使用快慢指针的方法,不过这里有一些比较巧妙的论证与计算。

首先,对于我们定义的快慢指针fastslow,在本题的求解过程中,双指针会产生两次“相遇”。

第一次相遇:

  • 设置指针fastslow,指向链表头部;
  • 每轮fast走2部,slow走一步;

如果链表存在环,那么双指针一定会相遇。因为每走 1 轮,fastslow 的间距 +1,fast 一定会追上 slow

设两指针分别走了FS的距离,因为fast走的步数是slow的两倍,因此我们有第一个关键公式:

  • F = 2 * S

其次,如下图所示,我们设定:

  • 第一次相遇的点为Pos
  • 环的连接点(即题目希望求解的位置)为Join
    • 该位置设为环的起始位置,只要绕的圈数为整数圈,那么一定落在Join点;
  • 头结点head到连接点Join的长度的为LenA;
  • 连接点Join到第一次相遇点Pos的长度为x
  • 环的长度为R;

    第一次相遇时,我们有:
  • slow走的长度为:S = LenA + x
  • fast走的长度为:F = LenA + n * R + x
    • 这里n * R是因为在slow进入到环前,fast可能已经在环内走了n圈了;

根据第一个公式F = 2 * S,因此我们有:

  • LenA = n * R - x

由于此时slowJoin点已经走了x距离,那么只需要再走R - x的距离即可到达Join点。
因此,假如此时在第一次相遇后,我们让fast重新指向headfastslow同时每轮一步、走LenA的距离,那么此时slow行走后所在位置为:

  • x + LenA = x + n * R - x = n * R

n * R恰好正是Join点所在的位置。

这个位置也恰好就是fastslow第二次相遇的位置。

补充:
如果觉得n * R不好理解,将LenA设置较短、n变为0即可。

算法代码

class Solution:
    def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:
        has_cycle = False
        slow, fast = head, head
        while fast and fast.next:
            slow = slow.next
            fast = fast.next.next
            if slow == fast:
                has_cycle = True
                break

        if not has_cycle:
            return None

        fast = head
        while fast != slow:
            fast = fast.next
            slow = slow.next
        
        return fast

21、合并两个有序列表(简单)

题目描述

将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

示例 1:

输入:l1 = [1,2,4], l2 = [1,3,4]
输出:[1,1,2,3,4,4]

示例 2:

输入:l1 = [], l2 = []
输出:[]

示例 3:

输入:l1 = [], l2 = [0]
输出:[0]

提示:

  • 两个链表的节点数目范围是 [0, 50]
  • -100 <= Node.val <= 100
  • l1 和 l2 均按 非递减顺序 排列

题目思路

对于这道题,整体较为简单,就是对两个链表同时进行遍历、不断修改next、最终达到重新组织排序的目的。

其中有几个注意点:

  • 需要新创建一个pre_node用于记录链表开头部分;
  • 定义p节点用于遍历、记录当前节点;
  • 最后只要list1list2还剩下元素,直接将其放在p后面即可;

算法代码

class Solution:
    def mergeTwoLists(self, list1: Optional[ListNode], list2: Optional[ListNode]) -> Optional[ListNode]:
        prev_head = ListNode(-1)
        p = pre_head
        while list1 and list2:
            if list1.val <= list2.val:
                p.next = list1
                list1 = list1.next
            else:
                p.next = list2
                list2 = list2.next
            p = p.next

        # 将剩下的链表直接放在结尾
        p.next = list1 if list1 else list2

        return prev_head.next
  • 24
    点赞
  • 21
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值