链表_总结(重点:环形链表)

指针的运用——快慢指针 学习快慢指针的运用 阅读详情

链表

141. 环形链表! 判断是否有环

面试问的比较多的一道题
https://leetcode.cn/problems/linked-list-cycle/

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

思路:利用快慢指针判断

我的思路:不对,这样不叫快慢指针,只是快指针在慢指针前面一步,但是前进的速度一样,这样永远追不上。

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

方法一:快慢指针

注,边界条件:如果链表是否为空或只有一个元素,肯定不存在环。

需要判断slow != fast,所以不能把slow和fast都设为head,而是slow设为head,fast设为head.next。

class Solution:
    def hasCycle(self, head: Optional[ListNode]) -> bool:
        if not head or not head.next:
            return False
        # 快慢指针
        slow = head
        fast = head.next

        while fast and fast.next:
            if slow != fast:
                fast = fast.next.next
                slow = slow.next
            else:
                return True
        return False

答案形式:

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

class Solution:
    def hasCycle(self, head: Optional[ListNode]) -> bool:
        if not head or not head.next:
            return False

        slow = head
        fast = head.next
        while slow != fast:
            if not fast or not fast.next:
                return False
            slow = slow.next
            fast = fast.next.next
        
        return True
  • 时间复杂度:O(N),其中 N 是链表中的节点数。
    当链表中不存在环时,快指针将先于慢指针到达链表尾部,链表中每个节点至多被访问两次。当链表中存在环时,每一轮移动后,快慢指针的距离将减小一。而初始距离为环的长度,因此至多移动 N 轮。
  • 空间复杂度:O(1)。我们只使用了两个指针的额外空间。

方法二:哈希表(更好理解)

使用哈希表来存储所有已经访问过的节点。每次我们到达一个节点,如果该节点已经存在于哈希表中,则说明该链表是环形链表,否则就将该节点加入哈希表中。重复这一过程,直到我们遍历完整个链表即可。

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

class Solution:
    def hasCycle(self, head: Optional[ListNode]) -> bool:
        # 哈希表
        record = set()
        cur = head
        while cur != None:
            if cur in record:  # 直接判断节点
                return True
            record.add(cur)
            cur = cur.next
        return False
  • 时间复杂度:O(N),其中 N 是链表中的节点数。最坏情况下我们需要遍历每个节点一次。

  • 空间复杂度:O(N),其中 N 是链表中的节点数。主要为哈希表的开销,最坏情况下我们需要将每个节点插入到哈希表中一次。

补充:142.环形链表II 返回入环节点

https://leetcode.cn/problems/linked-list-cycle-ii/

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

方法一:快慢指针

前提:快指针和慢指针都指向头节点。!!! 计算快指针和慢指针走过的距离,任意时刻,fast 指针走过的距离都为 slow 指针的 2 倍。建立等式。得出结论:从相遇点到入环点的距离加上 n-1 圈的环长,恰好等于从链表头部到入环点的距离。
因此,当发现 slow 与 fast 相遇时,我们再额外使用一个指针 ptr。起始,它指向链表头部;随后,它和 slow 每次向后移动一个位置。最终,它们会在入环点相遇。(起始点指针和相遇点指针)

# 代码随想录
# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def detectCycle(self, head: ListNode) -> ListNode:
        # 快慢指针,起始点指针,相遇点指针
        slow = head
        fast = head
        while fast and fast.next:
            slow = slow.next
            fast = fast.next.next
            if slow == fast:
                p = head   # 起始点
                q = slow   # 相遇点
                while p != q:
                    p = p.next
                    q = q.next
                return p
        return None

方法二:哈希表

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

class Solution:
    def detectCycle(self, head: ListNode) -> ListNode:
        # 哈希表
        record = set()
        cur = head
        while cur:
            if cur in record:
                return cur
            record.add(cur)
            cur = cur.next
        return None

怎么计算环内有几个节点?

方法一:

若链表中存在环,则快指针与慢指针必定相遇于环中任一结点,因此相遇时我们开始计数直到下次相遇,慢指针所移动步数即为环中结点个数(设环中结点数为r,另设从第一次相遇开始到第二次相遇时慢指针移动S步,那么快指针移动步数为2S,且有2S=S+r,因此r=S)。

我的写法:

class Solution:
    def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:
        slow, fast = head, head
        while fast and fast.next:
            slow = slow.next
            fast = fast.next.next
            if slow == fast:
                slow = slow.next
                fast = fast.next.next
                n = 1 # 统计环内节点数
                while slow != fast:
                    slow = slow.next
                    fast = fast.next.next
                    n += 1 
                # print(n)
                return n
        return 0

我的思路:起始点指针和相遇点指针到达入口节点前走过的节点数 + 从入口节点处到相遇点处的节点数 = 环内的节点数。
但是代码这样写,当链表是一个环时,记录的节点数为0。

class Solution:
    def detectCycle(self, head: ListNode) -> ListNode:
        # # 快慢指针,起始点指针,相遇点指针
        slow = head
        fast = head
        n = 0  # 统计环内节点数
        while fast and fast.next:
            slow = slow.next
            fast = fast.next.next
            if slow == fast:
                p = head   # 起始点
                q = slow   # 相遇点
                while p != q:
                    p = p.next
                    q = q.next
                    n += 1
                while q != fast:
                    q = q.next
                    n += 1
                print(n)
                return p
        return None

21. 合并两个有序链表

https://leetcode.cn/problems/merge-two-sorted-lists/
递归 链表

方法一:递归(不太能理解)

https://leetcode.cn/problems/merge-two-sorted-lists/solution/he-bing-liang-ge-you-xu-lian-biao-by-leetcode-solu/

class Solution:
    def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:
        if l1 is None:
            return l2
        elif l2 is None:
            return l1
        elif l1.val < l2.val:
            l1.next = self.mergeTwoLists(l1.next, l2)
            return l1
        else:
            l2.next = self.mergeTwoLists(l1, l2.next)
            return l2

方法二:迭代(更好理解)

定义一个虚拟节点
https://leetcode.cn/problems/merge-two-sorted-lists/solution/he-bing-liang-ge-you-xu-lian-biao-by-leetcode-solu/

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def mergeTwoLists(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:
        dummyHead = ListNode(-1)
        cur = dummyHead
        while l1 and l2:
            if l1.val <= l2.val:
                cur.next = l1
                l1 = l1.next
            else:
                cur.next = l2
                l2 = l2.next
            cur = cur.next
        # l1和l2中至少有一个不为None, 将链表末尾指向未合并完的链表
        cur.next = l1 if l1 else l2
        return dummyHead.next
  • 时间复杂度:O(n + m),其中 n 和 m 分别为两个链表的长度。因为每次循环迭代中,l1 和 l2 只有一个元素会被放进合并链表中, 因此 while 循环的次数不会超过两个链表的长度之和。所有其他操作的时间复杂度都是常数级别的,因此总的时间复杂度为 O(n+m)。
  • 空间复杂度:O(1)。我们只需要常数的空间存放若干变量。

203. 移除链表元素

https://leetcode.cn/problems/remove-linked-list-elements/

给你一个链表的头节点 head 和一个整数 val ,请你删除链表中所有满足 Node.val == val 的节点,并返回 新的头节点 。

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def removeElements(self, head: Optional[ListNode], val: int) -> Optional[ListNode]:
        dummyHead = ListNode(-1)
        cur = dummyHead
        dummyHead.next = head
        while cur.next != None:
            if cur.next.val == val:
                cur.next = cur.next.next
            else:
                cur = cur.next
        return dummyHead.next
class Solution:
    def removeElements(self, head: Optional[ListNode], val: int) -> Optional[ListNode]:
        dummyHead = ListNode(next = head)
        curNode = dummyHead
        while(curNode.next != None):
            if(curNode.next.val == val):
                curNode.next = curNode.next.next
            else:
                curNode = curNode.next
        return dummyHead.next

206. 反转链表

https://leetcode.cn/problems/reverse-linked-list/?envType=study-plan&id=shu-ju-jie-gou-ru-men

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

class Solution:
    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
        cur = head
        pre = None
        while cur != None:
            temp = cur.next
            cur.next = pre
            pre = cur
            cur = temp
        return pre

83. 删除排序链表中的重复元素

https://leetcode.cn/problems/remove-duplicates-from-sorted-list/

给定一个已排序的链表的头 head , 删除所有重复的元素,使每个元素只出现一次 。返回 已排序的链表 。

我的题解:

class Solution:
    def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:
        if not head:
            return head
        cur = head
        while cur.next != None:
            if cur.val == cur.next.val:
                cur.next = cur.next.next
            else:
                cur = cur.next
        return head

答案:

class Solution:
    def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:
        if not head:
            return head

        cur = head
        while cur.next:
            if cur.val == cur.next.val:
                cur.next = cur.next.next
            else:
                cur = cur.next

        return head

补充(算法学习计划_链表_双指针):

876. 链表的中间结点

https://leetcode.cn/problems/middle-of-the-linked-list/

给定一个头结点为 head 的非空单链表,返回链表的中间结点。
如果有两个中间结点,则返回第二个中间结点。

方法一:快慢指针法

用两个指针 slow 与 fast 一起遍历链表。slow 一次走一步,fast 一次走两步。那么当 fast 到达链表的末尾时,slow 必然位于中间。

class Solution:
    def middleNode(self, head: ListNode) -> ListNode:
        slow = fast = head
        while fast and fast.next:
            slow = slow.next
            fast = fast.next.next
        return slow
  • 时间复杂度:O(N),其中 NN 是给定链表的结点数目。

  • 空间复杂度:O(1),只需要常数空间存放 slow 和 fast 两个指针。

方法二:单指针法

可以对链表进行两次遍历。第一次遍历时,我们统计链表中的元素个数 N;第二次遍历时,我们遍历到第 N/2 个元素(链表的首节点为第 0 个元素)时,将该元素返回即可。

class Solution:
    def middleNode(self, head: ListNode) -> ListNode:
        n, cur = 0, head
        while cur:
            n += 1
            cur = cur.next
        k, cur = 0, head
        while k < n // 2:
            k += 1
            cur = cur.next
        return cur

24. 两两交换链表中的节点

https://leetcode.cn/problems/swap-nodes-in-pairs/

给你一个链表,两两交换其中相邻的节点,并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题(即,只能进行节点交换)。

方法一:直接交换

定义一个虚拟头节点

class Solution:
    def swapPairs(self, head: Optional[ListNode]) -> Optional[ListNode]:
        if not head or not head.next: return head
        dummyNode = ListNode(next=head)
        cur = dummyNode
        while cur.next != None and cur.next.next != None:
            # 暂存,有点绕
            tmp = cur.next
            tmp1 = cur.next.next

            tmp.next = tmp1.next
            tmp1.next = tmp
            cur.next = tmp1


            # 循环,准备下一轮交换
            cur = cur.next.next
        return dummyNode.next

19. 删除链表的倒数第 N 个节点

https://leetcode.cn/problems/remove-nth-node-from-end-of-list/

给你一个链表,删除链表的倒数第 n 个节点,并且返回链表的头节点。

思路:定义一个虚拟头节点,利用快慢指针。首先,快慢指针都指向虚拟头节点,然后快指针先走n步,之后快慢指针同时向后移动,当快指针走到结尾时,slow指针的下一个节点为倒数第n个节点。

class Solution:
    def removeNthFromEnd(self, head: Optional[ListNode], n: int) -> Optional[ListNode]:
        # 定义一个虚拟头节点
        dummyNode = ListNode()
        dummyNode.next = head

        slow = fast = dummyNode
        # 快指针先走n步
        for i in range(n):
            fast = fast.next
        
        while fast.next != None:
            slow = slow.next
            fast = fast.next

        # fast走到结尾后,slow的下一个节点为倒数第n个节点
        slow.next = slow.next.next
        return dummyNode.next

另一种写法:思路是一样的

class Solution:
    def removeNthFromEnd(self, head: Optional[ListNode], n: int) -> Optional[ListNode]:
        dummyNode = ListNode(next=head)
        slow = fast = dummyNode
        for i in range(n):
            fast = fast.next

        while fast.next != None:
            slow = slow.next
            fast = fast.next
        
        slow.next = slow.next.next
        return dummyNode.next

试了一下return head,在下面的情况下会报错。返回的是 [1][1][1]
输入:head = [1], n = 1
输出:[]

20221020 链表排序

148.排序链表&剑指 Offer II 077. 链表排序

  1. 排序链表 https://leetcode.cn/problems/sort-list/

给你链表的头结点head,请将其按升序排列并返回排序后的链表。
归并排序


147. 对链表进行插入排序

https://leetcode.cn/problems/insertion-sort-list/

给定单个链表的头 head ,使用插入排序对链表进行排序,并返回排序后链表的头。

插入排序 算法的步骤:
1.插入排序是迭代的,每次只移动一个元素,直到所有元素可以形成一个有序的输出列表。
2.每次迭代中,插入排序只从输入数据中移除一个待排序的元素,找到它在序列中适当的位置,并将其插入。
3.重复直到所有输入数据插入完为止。

代码随想录算法训练营第四天 || 24.两两交换链表中的节点 /19.删除链表的倒数第N个节点 / 面试题02.07.链表相交 / 142.环形链表II 本文总结了链表相关算法题解,包括两两交换节点、删除倒数第N个节点、链表相交和环形链表检测。关键点在于使用虚拟头节点简化操作,双指针技巧(快慢指针)解决特定位置问题,以及通过长度差处理链表相交问题。对于环形链表,需判断环的存在并找到入口节点。这些题目展示了链表操作中的常见模式,如临时指针保存节点、指针移动策略和边界条件处理。 阅读详情

相关推荐

有关SPSS中Fisher精确检验无法进行的解决方法(由于无法打开临时文件,因此无法进行计算)

最近在帮一个四年生完成她的毕业论文,在用SPSS进行R×C表检验的时候,发现Fisher精确检验的结果无法显示,提示为“由于无法打开临时文件,因此无法进行计算”,大概像下图一样。 (这图是从网上找的) 然...

chuyang37的博客 3万+

【力扣】链表操作

基础操作 反转链表 206. 反转链表 头插法 class Solution: def reverseList(self, head: ListNode) -> ListNode: dummy = ListNode() while head: node = head head = head.next node.next = dummy.next dummy.next

阿栗要努力成为ai大神 1522

基于轻量级神经网络MobileNet V2的水果识别种类算法研究

本文阐述了一种基于轻量级卷积神经网络MobileNet V2的水果分类与识别算法研究。为了最大限度地促进机械收获,需要一个检测系统,它可以让我们识别不同类别的水果。一个相对未开发的想法是使用深度学习和人工智能算法,不仅可以检测水果的种类,还可以检测水果是否成熟。这可以证明是有利可图的,因为它可以提供作物生长状况以及成熟和未成熟果实的个体数量,以及决定是否是收获时间的有用信息。第一步对数据进行了预处理,数据预处理技术在众多的深度学习计算中起到了重要作用。

qq_43556680的博客 1641

LeetCode热题100——链表

如果链表中有某个节点,可以通过连续跟踪 next 指针再次到达,则链表中存在环。为了表示给定链表中的环,评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置(索引从 0 开始)。给你两个单链表的头节点 headA 和 headB ,请你找出并返回两个单链表相交的起始节点。给你一个单链表的头节点 head ,请你判断该链表是否为回文链表。如果链表中存在环 ,则返回 true。给你单链表的头节点 head ,请你反转链表,并返回反转后的链表。给你一个链表的头节点 head ,判断链表中是否有环。

w风的季节-博客 744

Android Camera性能优化概述

做camera性能优化方面的工作有几年了,想写一篇文章简单介绍一下其中涉及到的具体技术,这篇文章会大概介绍一下涉及到的技术。

weixin_42136255的博客 4027

Docker安装Nacos(详细教程)

Docker安装Nacos的步骤相对直接,但需要注意一些细节以确保安装成功。

weixin_73060959的博客 1407

记录关于链表学习中的一些困惑

所以,尽管 `head` 在类型上是 `Optional[ListNode]`,它在功能上扮演的是指向链表第一个节点的指针角色。在Python中,`Optional[ListNode]` 是一个类型注解,它来自 `typing` 模块,用于表示一个值可以是 `ListNode` 类型,也可以是 `None`。在这个上下文中,`head` 被注解为 `Optional[ListNode]`,意味着 `head` 可以是一个 `ListNode` 对象,也可以是 `None`。变量所引用的对象的内存地址。

hahaha_1112的博客 1479

主板USB接口全部失效解决方案(通用串行总线USB控制器有黄色叹号)保姆级教程亲测有效

通用串行总线控制器总是有叹号解决办法 办公室的崩腾时代老电脑,疫情期间没人用,来了开机之后发现鼠标键盘都用不了,本以为是主机放时间长出了问题,后来想起来就百度了“鼠标键盘都失效”的标题,结果发现了“串行总线控制器总是感叹号”的关联问题。正好办公室电脑都装有teamviwer常用来远程办公(在家偷懒)。所以通过远程发现电脑室可以运行的。并在控制面板发现:通用串行总线控制器总是感叹号,插入外设时USB无反应。如图:​ 并且右键选中其中一个,点击最后一个选项:“属性” 可以发现“设备状态”中会提示“由...

xiao_bai_0_0的博客 2万+

datawhale组队学习笔记(2)链表

链表基础知识: 结构: ①逻辑结构:集合、线性结构(一对一)、树形结构(一对多)、图结构(多对多); ②存储结构:顺序存储(顺序表)、链式存储(链式表)、索引存储、散列存储。 2.链表分类: ①单链表、双链表、循环链表(单/双) ②带头结点/不带头节点 3.(单)链表操作: 插入元素、删除元素、创建单链表(尾插法/头插法) 结构: ①逻辑结构:集合、线性结构(一对一)、树形结构(一对多)、图结构(多对多); ②存储结构:顺序存储(顺序表)、链式存储(链式表)、索引存储、散列存储。 2.链表分类: ①单链表

m0_51677543的博客 606

从0入门LocoTrack:6倍加速的SLAM追踪新范式实战指南

传统点追踪方法(如CorrTracker、TAPIR)在处理大规模场景或实时任务时,要么精度不足,要么速度太慢。而LocoTrack通过“局部4D相关性”和“Transformer全局关联”的创新设计,实现了精度与速度的双重突破速度:比现有SOTA方法快6倍,吞吐量高达数万点/秒;精度:在Kinetics、DAVIS等数据集上,定位误差显著低于传统方法;鲁棒性:能应对低纹理、动态场景等复杂环境,这是传统方法的“噩梦场景”。

m0_71589036的博客 96

11.Labview实现用户界面切换的几种方式---通过VI间相互调用

本文介绍了界面切换的几种方式,分别是重入和引用①重入方式可以通过调用子VI的方式打开被调用的界面,往往应用于弹窗等的设置程序。②引用方式分两种,一种是打开引用,一种是静态引用。区别在于打开引用需要设置被打开VI的目标地址,静态引用仅需在引用时绑定VI的位置即可。③推荐使用静态引用的方式切换界面。④使用引用打开界面时,需通过属性节点和调用节点来设置程序的状态。更多内容欢迎大家补充和留言讨论~本文介绍了GUI界面设计相关的程序,更多相关文章后续持续更新,请关注作者不迷路~本期就到这里,再见~

关注我,更多技术问题欢迎私聊~ 9555

数据结构算法学习:LeetCode热题100-链表篇(上)(相交链表、反转链表、回文链表、环形链表、环形链表 II)

本文精选了LeetCode热题100中的五道经典链表问题,包括相交链表、反转链表、回文链表、环形链表等。针对相交链表问题,采用哈希集合的"登记-核对"方法;反转链表则通过三指针原地迭代实现;回文链表巧妙地结合快慢指针和反转前半部分来优化空间复杂度。文章详细解析了每道题的解题思路、具体步骤和代码实现,并进行了时间复杂度分析。这些解法不仅解决具体问题,更提炼出链表处理的通用范式,如双指针、空间换时间等核心思想,为后续数据结构学习奠定基础。

weixin_46446866的博客 1135

Arduino ESP32 Web服务器从microSD卡读取

Arduino ESP32 Web服务器从microSD卡读取 将网页内容放到SD卡中,当有客户端数据请求时,从SD卡读取信息进行发送,比起SPIFFS文件系统,更节约板上的硬件资源。 SD卡接线说明 ESP32----- SD D5(GPIO 5)-----CS D18(GPIO 18)-----SCK D19(GPIO 19)-----MISO D23()GPIO 23-----MOSI 文件放置 需要把文件放置到SD卡的根目录下。注意SD卡的格式FAT32格式。 实例代码 /*

perseverance51博客 1436

【经典题目】链表OJ(相交链表、环形链表、环形链表II、随机链表的复制)

本文主要介绍了有关链表的各种经典面试题目(相交链表、环形链表、环形链表II、随机链表的复制),内容全由作者原创(无AI),同时深度解析了题目的经典解决方法,并带有配图帮助博友们更好的理解,点个关注不迷路,下面进入正文~~

2502_94055806的博客 848

Statistics and Machine Learning Toolbox

Statistics and Machine Learning Toolbox(带书签),MATLAB统计学习工具

精雕软件(JDpaint) 5.5 绿色版

精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版

力扣234.回文链表、141.环形链表、142. 环形链表 II

由hot100里面的上一题,反转链表,非常笨蛋地直接就想到先把整个链表反过来然后对比...但是忽略了当我反转链表的时候头节点head就已经被修改为None了,无法再进行后面幻想的逐个节点比对。给的测试用例居然还全部通过了我真是被迷惑了(扶额苦笑。

qq_66799283的博客 878

ET2012新版免狗免安装绿色软件

ET2012新版免狗免安祖昂绿色软件。,新界面,新视觉,

【Day 17】234.回文链表 141.环形链表 142.环形链表II

234.回文链表 && 141.环形链表 && 142.环形链表II

2301_80182689的博客 803

计算机控制技术及应用

《计算机控制技术及应用》通过总结作者的科研成果和吸收国内外的先进理论、方法和技术,以计算机控制系统的网络化、开放化、智能化和集成化发展趋势为主线索,主要介绍计算机控制系统的基本概念和计算机控制系统的典型形式,计算机控制系统的数学描述与基本分析方法,以及数字PID控制器、最少拍控制系统、达林算法、状态变量设计法等设计方法及其各种改进算法。重点突出计算机控制系统输入输出通道接口的设计方法和典型控制系统的设计案例与实现方法等。

每日精讲:环形链表、两个数组中的交集、随机链表的复制

本文介绍了三个算法问题的解决思路和代码实现:1. 环形链表检测(使用C++ STL set存储节点指针);2. 两个数组求交集(使用set去重后对比);3. 随机链表的深拷贝(提供C语言节点插入法和C++ map映射法)。重点讲解了利用STL容器简化算法实现的过程,包括set的去重特性、map的节点映射关系等技巧。对于每个问题,文章都给出了题目描述、解决思路和完整代码实现,并分析了算法的时间复杂度。特别强调了对比算法在实际生活中的应用价值,如手机照片同步等场景。

2301_78901562的博客 7136

算法训练营第四天:链表相关重点精讲

本文摘要总结了算法训练营第四天的链表相关题目解法要点: 两两交换链表节点时需注意循环起始位置,通过新建头节点统一操作,确保不丢失节点地址; 删除倒数第N个节点推荐双指针法,快指针先走N+1步,需注意边界检查; 链表相交问题需先对齐链表尾部,再同步遍历比较节点地址; 环形链表检测使用快慢指针,相遇后重置指针可找到环入口。 关键技巧包括: 链表操作优先考虑虚拟头节点 增删节点需通过前驱节点操作 双指针法适用于倒数节点和环形检测 所有解法都强调指针操作的顺序和边界条件检查

yizhan_tian的博客 1481

leetcode_142 环形链表II

本文介绍了判断链表中环的入口节点的两种方法:哈希表法和Floyd判圈法。哈希表法通过遍历链表并记录访问过的节点,空间复杂度为O(n)。Floyd判圈法使用快慢指针,通过数学推导找到环入口,空间复杂度为O(1)。两种方法的时间复杂度均为O(n),但Floyd判圈法更节省空间。

bdn_nbd的博客 837

第四天| 24. 两两交换链表中的节点 、 19.删除链表的倒数第N个节点 、 160.相交链表 、 142.环形链表II

给定一个链表,两两交换其中相邻的节点,并返回交换后的链表。你不能只是单纯的改变节点内部的值,而是需要实际的进行节点交换。思考:每次处理要涉及到三个结点:要交换的两个结点以及前驱结点。注意循环结束条件以及操作先后顺序给你一个链表,删除链表的倒数第 n 个结点,并且返回链表的头结点。进阶:你能尝试使用一趟扫描实现吗?双指针法。快指针先移动n步,接着快慢指针一起移动,直到快指针指向结点为链表尾部指针时慢指针指向目标结点的前驱结点,然后删除链表结点操作。

Adore_master的博客 1087

环形链表的详解

本文探讨了链表环检测的两种方法: 1)使用快慢指针判断链表是否有环,分析了不同步长下的相遇条件; 2)找到环的起始节点。推导表明,当快指针步长为2时总能相遇,而步长为3时需满足特定奇偶 条件。 第二种方法通过相遇点和头指针同步移动,数学推导证明最终相遇点即为环的起始位置。文中提供了C语言实现代码,并通过图示和公式详细证明了算法的正确性。

2502_92159017的博客 898

C++刷 LeetCode Hot100 笔记(七)链表专题(上):反转链表、合并两个有序链表、删除链表的倒数第 N 个结点、环形链表、环形链表 II

反转链表:三指针合并链表:dummy + 尾插删除倒数第 N 个:快慢指针判环:快慢指针找环入口:快慢指针经典结论。

2301_79911329的博客 323

单链表算法思路详解(下)

本文针对四个链表问题提供解题思路和代码实现:1)相交链表通过计算长度差和同步遍历寻找交点;2)环形链表I使用快慢指针判断是否存在环;3)环形链表II基于相遇点推导入环节点;4)随机链表复制采用节点插入和分离技术实现深拷贝。每个问题都详细分析了核心算法、步骤拆解、代码实现及易错点,时间复杂度均为O(n),空间复杂度优化至O(1)。

2401_85409229的博客 1459

链表中环的入口节点(环形链表),剑指offer,力扣

给定一个链表,返回链表开始入环的第一个节点。从链表的头节点开始沿着 next 指针进入环的第一个节点为环的入口节点。如果链表无环,则返回 null。为了表示给定链表中的环,我们使用整数 pos 来表示链表尾连接到链表中的位置(索引从 0 开始)。如果 pos 是 -1,则在该链表中没有环。注意,pos 仅仅是用于标识环的情况,并不会作为参数传递到函数中。说明:不允许修改给定的链表。

m0_70437378的博客 699

Day02 数组&链表 | 66.加一、141.环形链表、21. 合并两个有序链表

倒序遍历数组,过滤器判断,如果元素不为9,则加1直接返回,如果为9,则将元素更新为0,遍历完成后还未结束,则说明 出现类似 999、9999等数据,新构建一个数组,首位更新为1即可。遍历链表,过滤器判断,判断1:谁链表已遍历完成则不用管,判断2:都没遍历完,谁小取谁。注意构建一个保护节点(和合并数组解法类似)快慢指针,遍历链表,慢指针每次走一步,快指针每次走2步,如果快指针和慢指针数据相等,则说明相遇了,即证明有环,否则,无环。

三少 240

leetcode算法141.环形链表

leetcode算法141.环形链表

真正的大师永远怀着一颗学徒的心 830
上一篇: 算法入门_day06_滑动窗口
下一篇: 数据结构专题_树
Pythonistas29xs
博客等级 码龄8年 27粉丝 30原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Pythonistas29xs

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值