删除链表倒数第N个节点:三种解法与快慢指针实战

C语言——删除链表的倒数第N个节点 给定一个链表,删除链表的倒数第n个节点,返回链表的头节点head。 阅读详情

LeetCode 19这道题,我刷过很多遍,每次带新人刷链表专题也会拿它当第一个案例。原因很简单,题面短、思路多、坑也不少,既能考察链表基本功,又能引出快慢指针这样经典的思想,性价比非常高的题目。这篇文章我想把这道题的三种最优解法从头到尾拆一遍,顺便把我在实际刷题和面试里踩过的坑都倒出来,希望能帮你少走点弯路。

原题是这样的:给你一个链表,删除链表的倒数第 n 个结点,并且返回链表的头结点。这不难理解,难就难在怎么把“倒数第n个”这件事做得又快又稳。接下来我们直接进入正题,从题目拆解开始,一步步把三种解法吃透。

1. 题目拆解与整体设计思路

1.1 题目原貌:它真正想考什么

LeetCode 19的字面意思很简单,但实际上埋了三个考点。

第一个是“倒数”。单向链表的天生缺陷就是只能从前往后走,没办法回头,所以“倒数第n个”这个语义,必须被转换成我们可以直接操作的“正数第几个”,或者设计一个不用知道总数也能找到目标的方法。这考的是对链表这个数据结构本身的理解——它没有随机访问能力,一切操作都得靠遍历。

第二个是“删除”。别看删除只有一行代码,真正动手改的是目标节点的前一个节点的next指针。也就是说,无论你用哪种方法,最终都要找到目标节点的前驱节点,而不是目标节点本身。这个细节几乎每个新手都会踩,包括我自己第一次写的时候,也是习惯性地把指针停在目标节点上,结果删了个寂寞。

第三个是“头节点可能被删”。如果n等于链表的长度,那要删的就是head自己。这种情况下,删除逻辑需要单独处理,否则很容易报空指针错误。这也是为什么几乎所有链表删除题都会推荐引入哑节点dummy node。

1.2 三种解法的技术选型全景

这道题的解法非常丰富,常见的就有三种:长度法、快慢指针、栈。为了让你一开始就对全局有数,我先把它们并排放在一起看个概览:

解法 核心思想 时间复杂度 空间复杂度 最佳应用场景
长度法 先数长度,再走L-n步找前驱 O(L) O(1) 新手打底、思路热身
快慢指针 fast先走n+1步,slow再同步前进 O(L) O(1) 一趟扫描、面试正解
栈 节点全部入栈,弹出n个后取栈顶 O(L) O(L) 变形题、快速实现

长度法是理解这道题的逻辑地基,它把“倒数”直接翻译成“正数”,思路最直白。快慢指针则是题目进阶要求的最佳答案,一趟扫描搞定,也是面试里最常被期待的回答。栈的方法相对冷门,思维角度很巧妙,利用后进先出的特性天然地“只看尾部”,在很多链表变形题里有奇效。

三者的关系不是互斥的,而是同一道题的三个不同侧面。我的建议是:先用长度法把边界条件练扎实,再把快慢指针作为主力答案熟练掌握,最后把栈的视角作为备用方案备着。不要死记三种代码,而是理解每一种方法在什么样的约束条件下会更自然,这样才能在面试时真正有选择的底气。

2. 解法一:长度法——最直观的基线方案

2.1 核心思路与边界处理

长度法的核心逻辑一句话就能说清楚:先遍历一遍链表,数出总长度L;那么倒数第n个节点就是正数第L-n+1个节点;删掉它需要找到它的前驱,也就是正数第L-n个节点。所以第二趟遍历时,从dummy出发,走L-n步,就停在了目标节点的前驱上,然后修改next指针,结束。

这里有两个关键点,是长度法最容易出错的地方。

第一个是“前驱”的位置要算准。举个例子,链表是1→2→3→4→5,n=2,我们要删的是4,它的前驱是3。L=5,L-n=3,也就是说从dummy这个虚拟的第0个节点出发,向前走3步,落在3上。很多新手写循环时容易下意识写成range(L-n+1),这样走4步就到了目标节点4身上,当然没法删。解决办法很简单:在草稿纸上画图,养成给节点编号的习惯。dummy标0,1标1,依次往后标,目标节点永远是L-n+1,它的前驱永远是L-n,数清楚再写代码。

第二个是处理“头节点”。如果n等于链表长度,目标节点是head,它没有前驱,直接改指针就行不通。所以长度法务必使用dummy节点,dummy的next指向head。这样就算要删head,dummy也是它的前驱,不需要任何额外分支。返回值也要记得写成return dummy.next而不是return head,因为head有可能已经被删掉了。

2.2 完整代码与复杂度分析

下面是长度法一个比较标准的实现,我加了详细注释:

class Solution:
    def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:
        # 哑节点:统一处理头节点被删的边界情况
        dummy = ListNode(0, head)
        length = 0
        cur = head

        # 第一趟遍历:统计链表长度
        while cur:
            length += 1
            cur = cur.next

        cur = dummy
        # 第二趟遍历:走到目标节点的前驱
        # 从dummy开始是第0步,length-n步正好到前驱
        for _ in range(length - n):
            cur = cur.next

        # 执行删除
        cur.next = cur.next.next
        return dummy.next

时间复杂度方面,两趟遍历,每趟最多O(L),总体还是O(L)。空间复杂度只用到了几个指针变量,是严格O(1)。

在LeetCode的测试用例下,这个解法其实跑得也很快,因为它毕竟只是两个线性循环,性能上和快慢指针很难拉开肉眼可见的差距。但它有一个致命弱点:如果面试官追问“能不能只遍历一趟”,长度法就答不上来了。所以这道题真正的面试重心,还得看快慢指针。

2.3 长度法实务心得

我之所以把长度法放在首位,不是让各位拿它去当面试最终答案,而是因为它是最好的思维热身。链表题的边界条件多而杂,直接上手最优解很容易翻车。先把最简单的思路跑通,等于把那些坑都提前踩了一遍,再写进阶解法时心里就踏实多了。

举我自己的例子。第一次写长度法时,第二趟循环我也写错了,走的是range(L-n+1),结果指针停在了目标节点上,怎么删都不对。后来在草稿纸上把dummy到每个节点的下标都标出来,才发现自己把前驱和目标的位置搞混了。从那时起我就总结了一个口诀:找前驱永远比找目标少走一步。这个口诀在我写快慢指针时也救了我一次,因为快慢指针同样要找前驱,如果你没在长度法阶段把这个意识刻进脑子里,写快慢指针时很容易少加那关键的1步。

3. 解法二:快慢指针——一趟扫描的经典解法

3.1 核心思路推导:为什么快慢指针能做到

快慢指针是这道题的灵魂解法,也是面试官最想听到的方案。它背后的逻辑其实可以用一个生活场景来理解。

想象你和一个朋友站在同一起点,你先出发,以每秒1米的速度往前走,等你走了10米,朋友才以同样的速度出发。之后你们之间的距离就永远锁定在10米。当朋友到达终点时,你距离终点也正好还有10米。

链表里的快慢指针完全就是这个模型。设置两个指针fast和slow,先让fast走n步,然后slow再和fast同步前进。由于fast始终比slow快n个节点,当fast走到链表末尾的None位置时,slow正好停在倒数第n个节点的位置上。这就是把“倒数”问题拆分成了“相对距离”问题,而且全程不需要知道链表总长。

但别忘了我们真正想要的是前驱节点。所以标准解法里有一个关键微调:让fast先走n+1步,然后再让slow出发。这样,fast到达末尾时,slow自然落在比目标节点还靠前一位的地方,也就是它的前驱。这一步n+1是非常重要的细节,很多人按直觉只走n步,最后发现停在目标节点上,只能额外再加一个指针去记住前驱,代码瞬间就变臃肿了。

3.2 完整代码与逻辑走查

class Solution:
    def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:
        dummy = ListNode(0, head)
        fast = dummy
        slow = dummy

        # fast先走n+1步,让slow最终停在目标节点的前驱
        for _ in range(n + 1):
            fast = fast.next

        # 两个指针同步前进,fast到达None时,slow就在目标前驱上
        while fast:
            fast = fast.next
            slow = slow.next

        slow.next = slow.next.next
        return dummy.next

我们来手动走查一个例子,链表1→2→3→4→5,n=2。

  • 初始化:dummy→1→2→3→4→5,slow和fast都指向dummy。
  • fast先走3步,也就是n+1=3。fast从dummy依次经过1、2,最后停在3。
  • 然后fast和slow一起动。fast从3走到4,slow从dummy走到1;fast从4走到5,slow从1走到2;fast从5走到None,slow从2走到3。
  • 最后slow停在3,正好是目标节点4的前驱。执行slow.next = slow.next.next,4就被摘掉了,结果为1→2→3→5。

这个走查过程强烈建议大家自己在纸上画一遍。链表题目最大的敌人是“脑子仿佛懂了”,因为指针的跳转完全可以靠直觉脑补,但实际写起来却容易错。只有亲手把每一步的指针变化写下来,手感才会真正长出来。

3.3 快慢指针面试加分细节

快慢指针本身已经是进阶要求里的“一趟扫描”,但真正让面试官眼前一亮的,通常是一些小细节。

第一,为什么用dummy。如果不引入dummy,删除头节点的场景需要额外写一个条件分支,比如if not fast: return head.next。这个分支会让代码变得不够优雅,也容易在紧张时漏写。引入dummy后,删除头节点和其他节点完全同一套逻辑,代码的稳定性更高。

第二,n+1步的来由要能讲明白。如果面试官追问为什么是n+1,你可以这样回答:两个指针相差n个节点时,fast到达末尾,slow指向倒数第n个节点;但因为删除需要前驱,所以让fast再多走一步,使两个指针相差n+1个节点,slow就会落在倒数第n+1个节点上,也就是目标节点的前驱。把这一步讲清楚,等于直接堵住了追问。

第三,防御性编程。LeetCode原题的n保证在有效范围内,但面试官非常喜欢改编题目,比如把条件改成“n可能大于链表长度”。此时快慢指针的fast先走n步,如果中途就遇到了None,说明n非法,直接返回原链表即可。养成这种防御性习惯,能在面试里大大加分。

4. 解法三:栈——空间换时间的另一种视角

4.1 核心思路与适用场景

栈这个方法经常被忽略,但它有一个非常独特的切入点:单向链表的“倒数”操作,本质上就是想去尾部往前数。而栈正好是一种天然支持从尾部回看的数据结构。

做法是这样的:准备一个栈,把链表的所有节点依次压进去。压栈完成后,栈顶就是链表尾节点,栈底就是头节点。要删除倒数第n个节点,只需要连续弹出n个节点,弹出的那些正是链表的末尾n个。弹完之后,新的栈顶就是倒数第n+1个节点,也就是我们一直在找的目标节点的前驱。拿到前驱,删除就很简单了。

这里有一个细节:入栈时要包含dummy节点。原因和前面一样,当头节点就是目标节点时,如果栈里只有真实节点,连续弹n个后栈会变成空栈,就没法取前驱了。把dummy先压进去后,无论删哪个节点,栈都不会空,逻辑可以做到完全统一。

栈方法和快慢指针的取舍很清晰。快慢指针空间O(1),无论链表多长都不慌,这是它的绝对优势。栈方法代码直观,不需要理解“n+1”这种相对距离的偏移思想,几乎不会写错。如果链表有几百万个节点,栈方法要额外存储所有节点,内存压力会大;但如果面试时间紧,需要一个快速准确的方法,栈往往是保底的神器。所以我们不要给三种解法分高下,它们只是不同条件下的工具。

4.2 完整代码与边界处理

class Solution:
    def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:
        dummy = ListNode(0, head)
        stack = []
        cur = dummy

        # 全部节点入栈,包括dummy
        while cur:
            stack.append(cur)
            cur = cur.next

        # 弹出末尾n个节点
        for _ in range(n):
            stack.pop()

        # 栈顶现在是要删节点的前驱
        prev = stack[-1]
        prev.next = prev.next.next
        return dummy.next

这段代码的边界处理非常干净:

  • 链表只有一个节点且n=1:入栈后栈里是[dummy, head],弹出一个节点,head被弹出,栈顶变成dummy。prev是dummy,prev.next指向head,删除后dummy.next为空,正确。
  • 链表长度为L且n=L:本质上也是删除头节点,过程和上面完全一样,得益于dummy的存在,没有单独分支。
  • 如果链表为空:dummy也会入栈,栈不为空,代码不会崩溃,只是返回空链表。

栈方法的代码可能是三种解法里最短的,因为它避开了所有找前驱的数学计算,把存下来的节点按后进先出的顺序自动翻了面。这也是它作为备选方案的最大价值。

4.3 栈解法的实务思考

我第一次写栈方法时,心里是有点犹豫的,觉得空间O(L)会不会不够“高级”。后来刷得多了才明白,LeetCode的测试用例链表长度普遍只有几百到几千,栈方法的空间开销完全在可接受范围内,运行速度甚至不比其他方法慢。面试官只有在明确要求“常数空间复杂度”时才会否定它。其余时候,他们更看重的是你能不能用多种思路解题,以及每种思路的优缺点是否讲得清。

栈方法还有一个隐藏优势,就是扩展性好。举个例子,如果把题目改成“删除倒数第n个到倒数第m个之间的所有节点”,快慢指针需要重新调整起始位置和相对距离,非常麻烦。而栈方法只需在弹出环节连续处理一段范围内的节点,思路几乎不变。再比如,“从链表尾部数第k个节点”这种略带歧义的题目,栈方法天然从尾部开始操作,写起来基本不会误解题。

所以我的建议是,不要因为栈方法空间复杂度是O(L)就完全抛弃它。把它当作解决变形题的利器,会有意想不到的收获。

5. 三种解法对比与实战避坑指南

5.1 复杂度与代码量横向对比

三种解法放在一张表里,差异会非常直观:

解法 遍历次数 额外空间 代码量 核心风险
长度法 2趟 O(1) 约12行 第二次循环步数算错
快慢指针 1趟 O(1) 约11行 n+1步忘记加一
栈 1趟 O(L) 约9行 忘记把dummy入栈

从代码量看,栈方法最简练;从空间看,长度法和快慢指针最省;从遍历次数看,快慢指针和栈都能算作一趟扫描。但注意,栈方法虽然是“一趟扫描”,它实质上只是把所有节点都暂存起来,删除动作发生在遍历完成后,所以时间复杂度仍然和长度法一样是O(L),并不会更快。

我的整体判断是:日常刷题,用长度法建立正确思路框架;面试做最优解,优先写快慢指针;遇到各类变形题需要快速实现,栈方法是最不容易出错的兜底方案。三者各司其职,没有唯一的万能解。

5.2 面试考场上怎么选

面试场景和单纯刷题不一样,它有强烈的时间压力和沟通成本,所以策略很重要。

开场先别急着写。拿到题目后,我建议先花十几秒把题目核心用一句话复述出来,比如“这道题本质是找到倒数第n个节点的前驱,然后改指针”,然后主动问一句“有没有一趟扫描的限制”。这句话看着简单,但它传达了两个信息:第一,你抓住了问题本质;第二,你具备确认需求的习惯。面试官对接下来的解题过程会更有耐心。

如果面试官说不限一趟,那就用“从朴素到优化”的推进策略。先快速写出长度法,确保正确性,然后说“我可以优化到一趟扫描”,再补充快慢指针解法。这种“先正确、后优化”的路径,非常符合工程实践中的思维方式,会给你加分不少。如果一开始就被要求一趟扫描,那直接快慢指针,栈方法可以作为备用口头方案提一句,展示思路广度。

写出代码之后,还有一个重要的动作。我会在脑子里手动跑一个小用例,比如链表1→2→3,n=2,走一遍快慢指针的流程。这一步非常管用,能提前抓住很多低级错误,比如fast走了n+1步后停在了错误位置。

5.3 链表题通用的避坑清单

最后把这几年刷链表题积攒下来的坑,整理成一份清单,这些经验在大多数链表删除类题目里都适用。

  • 返回值永远用dummy.next。head可能在删除过程中被删掉,也可能因其他操作被改变,只有dummy.next才是稳定可靠的链表头。
  • 找前驱是第一目标。不管你用哪种解法,动手前先问自己一句:我设计的指针停在目标节点,还是它的前驱?停在目标节点上,删除逻辑是无法执行的。
  • 脚本语言里不要用递归解链表题。链表可能很长,递归会导致调用栈过深,而且面试官通常不会期待这种写法。
  • 写完代码必走查。至少用三个用例验证:删最后一个节点、删中间节点、删第一个节点。这三个位置基本覆盖了所有边界情况。
  • 注意n的有效范围。LeetCode会保证n在范围内,但面试改编题未必,对n做合法性校验是很好的加分习惯。

我还想分享一个小细节。写完快慢指针后,我习惯瞄一眼fast和slow的初始化,确认两个指针都是从dummy出发的。这个检查看似多余,但它成本极低,收益极高。因为一旦把fast初始化成了head,整个相对距离就会整体偏移一个节点,测试用例必挂。

6. 写在最后的实战体会

LeetCode 19这道题,刷一次很难真正掌握,但它的价值在于能帮你打通链表删除类问题的一整条脉络。长度法让你理解“倒数”和“正数”的换算关系,快慢指针让你体会通过“相对距离”省去预扫描的技巧,栈方法则给你一个看待链表尾部操作的崭新视角。

我个人在实际操作中的体会是:链表题最重要的不是背下三种解法,而是养成动笔前先画图的习惯。每道链表题,先花两分钟把节点编号画出来,把目标节点、前驱节点标清楚,再动手写代码,准确率会高很多。这也是我在带新人时反复强调的第一步。

最后送大家一个顺手的小技巧:如果你在LeetCode上连续遇到好几道链表题都卡壳,不妨把19题当作练习起点,把它作为链表基础操作的“文曲星试题”来认真对待。三道解法都写通透了,后续的反转链表、环形链表、链表排序都会顺利不少。

LeetCode 19 删除链表倒数第 N 个节点:快慢指针详解与边界处理 链表是数据结构中最基础也最常考的类型之一,而双指针技巧则是解决链表问题的核心利器。在单向链表只能顺序访问的限制下,定位“倒数第 N 个节点”往往需要巧妙利用指针间的距离差。快慢指针通过先让快指针前进 N 步,再让两个指针同步移动,即可在一次遍历内锁定目标节点的前驱位置,从而高效完成删除操作。这一方法不仅解决了经典算法题,还广泛适用于环形链表检测、寻找链表中点、旋转链表等高频面试场景。理解快慢指针背后的相对位置原理,能够帮助开发者从“背题解”进阶到“真懂链表”。本文以 LeetCode 第 19 题为例,深入 阅读详情

相关推荐

CentOS 9 Stream 上安装 MySQL 8.0+

根据提示进行设置,包括设置新的 root 密码、禁用远程 root 登录等。MySQL 在首次安装时会生成一个临时密码。这样就完成了 MySQL 8.0.37 的安装。这将安装最新的 MySQL 8.0 版本。

小强不是坑 1683

删除链表倒数第N个节点【快慢指针】【指向删除节点的前一个节点?】

删除链表倒数第N个节点是双指针技巧的经典应用,它不仅考察对链表结构的理解,更是快慢指针思想的完美体现。本文将从基础的双指针法开始,深入探讨为什么需要指向删除节点的前一个节点,并通过详细的图示说明删除过程。虚拟头节点:统一处理头节点和其他节点的删除快慢指针:通过快指针先走n+1步,然后同步移动找到删除位置指向删除节点的前一个节点:这是删除操作的关键技巧一次遍历:时间复杂度O(n),空间复杂度O(1)删除节点:始终指向要删除节点的前一个节点快慢指针:快指针先走特定步数,然后同步移动虚拟头节点。

weixin_47868976的博客 1127

uniapp实现app版本发现新版本后,自动更新

app实现自动更新

oldolder的博客 1287

07-删除链表的倒数第N个节点

删除链表的倒数第N个节点1. 双指针的经典应用1.1 解法一1.2 解法二2. 其他方法 leetcode题目链接 1. 双指针的经典应用 推荐大家使用哨兵节点,也就是虚拟头结点,这样方面处理删除实际头结点的逻辑。 在对链表进行操作时,一种常用的技巧是添加一个哑节点(dummy node),它的 next 指针指向链表的头节点。这样一来,我们就不需要对头节点进行特殊的判断了。 1.1 解法一 思路: 由于我们需要找到倒数第 n 个节点,因此我们可以使用两个指针 firs和 second 同时对链表进行遍历

其木王·王子的博客 2532

[附源码]计算机毕业设计JAVA网上花店系统

附源码]计算机毕业设计JAVA网上花店系统项目运行环境配置:(Webstorm也行)+ Eclispe(IntelliJ IDEA,Eclispe,MyEclispe,Sts都支持)。项目技术:等等组成,B/S模式 + Maven管理等等。环境需要1.运行环境:最好是java jdk 1.8,我们在这个平台上运行的。其他版本理论上也可以。2.IDE环境:IDEA,Eclipse,Myeclipse都可以。推荐IDEA;3.tomcat。

ssm毕设程序设计 2449

【重启后nvidia-smi 命令出现错误】

NVIDIA-SMI has failed because it couldn't communicate with the NVIDIA driver. Make sure that the latest NVIDIA driver is installed and running.

qq_44769377的博客 5217

链表操作:删除倒数第N个节点的快慢指针解法

链表作为基础数据结构,通过指针连接实现动态内存分配,其插入删除操作效率优于数组。快慢指针是解决链表问题的经典技巧,通过控制指针移动步数实现高效定位,在算法面试和工程实践中均有广泛应用。本文以删除倒数第N个节点为例,详解如何运用dummy节点处理边界条件,分析指针移动的步数控制与循环终止条件等关键技术细节。该解法时间复杂度O(n)且空间复杂度O(1),适用于内存管理、网络协议等需要高效遍历的场景,同类技巧还可应用于链表环检测、中间节点查找等问题。

weixin_34274029的博客 370

到底什么是电源的斜波补偿,电源芯片CS引脚作用,一文讲清楚!

上文有提到电流环,其实电流环再细分也有很多模式,用的最多的是峰值电流模式峰值电流模式调节工作原理如下:(1)当输出负载增大时,输出电压降低,因此,Vc 增大,线性增加的电感电流只有升高到更大的值才能使 PWM 电流比较器翻转,开关管导通的时间增长,占空比增加,输入功率增加,因此输出电压增加,当输出电压增加到调节的范围内时,系统保持平衡。

jwgdhuwdhg的博客 1万+

链表操作:快慢指针删除倒数第N个节点

链表是数据结构中的基础类型,通过指针连接实现动态存储。快慢指针是解决链表问题的经典技巧,通过控制指针移动步数差,可以在单次遍历中定位特定节点。这种方法在删除倒数第N个节点等问题中展现出O(n)时间复杂度的优势,广泛应用于内存管理、文件系统等场景。LeetCode等编程题库常以此考察算法基本功,结合虚拟头节点等工程技巧,能有效处理边界条件。掌握这类双指针算法对提升代码效率和解链表面试题都很有帮助。

weixin_33947521的博客 437

一文读懂客户健康度

什么是客户健康度?客户健康度为什么重要?怎么计算客户健康度?这篇文章,我们来聊聊。

m0_62700043的博客 1422

第10篇:Agent + 爬虫 = 全自动数据采集专家

在企业级数据采集场景中,传统爬虫的痛点已经到了无法忽视的地步:而Agent + 爬虫的组合,就是这些痛点的终极解决方案。它的核心逻辑是:把爬虫从「人工写死的固定执行脚本」,升级为「能自主分析、自主决策、自主适配、自主修复的智能采集机器人」。我们在生产环境中做过对比测试:传统爬虫开发10个网站的采集脚本需要3人天,而Agent采集机器人只需要3分钟,页面改版后的修复成本从1人天降到了0,采集任务的成功率从62%提升到了95%以上。终端执行以下命令,安装基础依赖,与前9篇环境完全兼容: 二、核心能力拆解:Age

专注于Python爬虫开发,分享爬虫技巧、项目实战与反爬经验,使用Scrapy、BeautifulSoup等工具,解决数据抓取难题。 1578

【链表】快慢双指针——python解决 删除链表倒数第n个结点

在解决链表的很多问题时,设置快慢指针是一个很好的解决思路。 这次问题的是删除链表倒数第 n 个结点。 例如, 1 -> 2 -> 3 -> 4 -> 5,删除倒数第2个变成 1 -> 2 -&g

scxyz的博客 839

AI编程工具深度对比:Cursor、Copilot、Trae与Claude Code,2025年开发者该如何选择?

2025年AI编程工具市场已形成四大主力阵营:Cursor(AI原生IDE)、GitHub Copilot(行业标准)、Trae(中国免费方案)和Claude Code(终端交互)。核心差异体现在技术能力(代码生成准确率85%-95%)、智能体协作程度和上下文处理能力(8K-200K tokens)。用户体验方面,Trae对中文支持最佳且免费,Copilot企业集成强,Cursor平衡易用与功能,Claude Code适合高阶开发者。实际测试显示,不同工具在原型开发、算法实现等场景各有优势

fudaihb的博客 6504

【LeetCode: 19. 删除链表的倒数第 N 个结点 | 链表 + 快慢指针】

【LeetCode: 19. 删除链表的倒数第 N 个结点 | 链表 + 快慢指针】给你一个链表,删除链表的倒数第 n 个结点,并且返回链表的头结点。

Coder_ljw的博客 959

Camera2Demo

在Camera2 的基础上进行封装,使得Camera2一堆初始化逻辑与Activity分离,降低耦合度,完成预览拍照并保存的操作

全球国家地区城市数据

MySQL全球国家地区城市数据报。。。。。。。。。。。。

删除链表倒数第 N 个结点:快慢指针与虚拟头节点详解

在算法与数据结构面试中,链表是最基础也最常考的线性结构之一。删除链表倒数第 N 个结点是一道经典题目,核心难点在于单链表的单向性——无法从后向前遍历。为了高效定位目标结点,常采用两次遍历或快慢指针方案,其中快慢指针通过先让快指针移动 N+1 步,再与慢指针同步前进,从而在一次扫描内找到待删结点的前驱。虚拟头节点(dummy node)的引入则能统一处理删除头结点等边界条件,大幅简化逻辑。这类技巧广泛应用于链表中间节点查找、环形链表检测、回文链表判断等场景,是工程师应对大厂算法面试必须掌握的套路。本文以 Le

weixin_30086969的博客 210

VB摄像头监控

该VB模块可对摄像头捕获的画面进行录像等,可在创建的窗口进行控制

单链表删除倒数第N个节点

难度:两星 如何删除单链表得倒数第N个节点?这里依然利用快慢指针的办法,让slow指针指向第一个节点,让fast指针和slow间隔N个节点,即指向第N个节点。然后同时移动slow和fast,每次前进一步,直到fast指针到最后一个指针,此时slow指针就是倒数第N个节点,是不是觉得很巧妙?这里找到了第N个节点之后需要删除掉这个节点,那么因为是单链表,我们必须保留被删除节点之前的这个节点,以及被删...

683

大中型超市收银系统(可直接运行)

光步前台收银系统系统功能:商品销售、商品退货、挂单、收银员权限、会员销售、单品取消、整单取消、商品查询、脱机销售、脱机数据上传,基本资料下载,开钱箱、小票打印、收款结算,支持多币种付款方式(现金、储值卡、礼券、微信等),支持多种促销。运行环境:.net 4.0登陆信息用户名:1001 密码:123456内置商品信息,商品编码可输入00001000 - 00010000,测试效果相关功能键F5 结算 F9挂单 F11商品查询 F8退货 Insert单品取消 Del整单取消 F12开钱箱F2 会员 Ctrl+Z退出系统 Home 锁屏 相关源码待公开

LeetCode——删除链表的倒数第N个节点(快慢指针)

题目描述 解题思路 删除链表的倒数第N个结点,有很多种解法,本次我们重点介绍的是快慢指针法,快慢指针在解决链表问题的时候,通常能够快速解决问题,这主要取决于快慢指针的特点。 快慢指针为什么能够找到链表的倒数第N个节点 假设一个链表有五个节点,我们想要删除倒数第2个节点,我们首先让快指针、从第一个节点的位置触发,走2+1个节点,我们能够发现此时快指针有两种情况,一是走到了null,二是走到了倒数倒数第2个节点,此时我们分情况讨论: 快指针走到了null,此时如果还没有走完n + 1个节点 让满秩

Always-Learning 1140

19. 删除链表的倒数第N个节点(快慢指针)

19. 删除链表的倒数第N个节点 给定一个链表,删除链表的倒数第 n 个节点,并且返回链表的头结点。 示例: 给定一个链表: 1->2->3->4->5, 和 n = 2. 当删除了倒数第二个节点后,链表变为 1->2->3->5. 说明: 给定的 n 保证是有效的。 进阶: 你能尝试使用一趟扫描实现吗? 分析:快慢指针 让快指针先走n步,然后快慢指针一起...

qq_39457296的博客 345

力扣19题:删除链表的倒数第N个节点

题目:给定一个链表,删除链表的倒数第 n 个结点

weixin_47337647的博客 655

[快慢指针]19 - 删除链表的倒数第N个节点 - python + Java

给定一个链表,删除链表的倒数第 n 个节点,并且返回链表的头结点。 示例: 给定一个链表: 1->2->3->4->5, 和 n = 2. 当删除了倒数第二个节点后,链表变为 1->2->3->5. 说明:给定的 n 保证是有效的。 进阶:你能尝试使用一趟扫描实现吗? 如果不要求使用一趟扫描就实现结点的删除,暴力的方法可以先读取链表中所有的结点到...

Forlogenの解忧杂货铺 378

LeetCode 19. 删除链表的倒数第N个节点 (C语言)

19. 删除链表的倒数第N个节点 Description 给定一个链表,删除链表的倒数第 n 个节点,并且返回链表的头结点。 示例: 给定一个链表: 1->2->3->4->5, 和 n = 2. 当删除了倒数第二个节点后,链表变为 1->2->3->5. 说明: 给定的 n 保证是有效的。 Analyze 给定的函数如下: @param head 链表头结点(带数据) @param n 一个整数,表示要删除的倒数第

狂吃不胖温同学的博客 587

[链表|多解法] leetcode 19 删除链表的倒数第N个节点

[链表|多解法] leetcode 19 删除链表的倒数第N个节点 1.题目 题目链接 给定一个链表,删除链表的倒数第 n 个节点,并且返回链表的头结点。 示例: 给定一个链表: 1->2->3->4->5, 和 n = 2. 当删除了倒数第二个节点后,链表变为 1->2->3->5. 说明: 给定的 n 保证是有效的。 进阶: 你能尝试使用一趟扫描实现吗? 2.分析 2.1.直观解法 既然要删除倒数第N个结点,那么统计出链表总共有多少个结点,然后就可以找到倒数第

xiongxyowo的博客 229

【链表】删除链表的倒数第N个节点

原题: 删除链表倒数第N个节点 第一种解法: 本文适用于初学者。它介绍了以下内容:链表的遍历和删除其末尾的第 n 个元素。 /** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode(int x) { val ...

小诚信驿站 572

leetcode19.删除链表倒数第N个节点 快慢指针

题目 给定一个链表,删除链表的倒数第 n 个节点,并且返回链表的头结点。 示例: 给定一个链表: 1->2->3->4->5, 和 n = 2. 当删除了倒数第二个节点后,链表变为 1->2->3->5. 说明: 给定的 n 保证是有效的。 进阶: 你能尝试使用一趟扫描实现吗? 可以两遍扫描,第一遍求出长度。代码略,运行时间8ms。 使用快慢指针实现一遍扫描,运行时间4ms。 解题思路 快慢指针 两指针初值都是head 快指针先走n个 然后两个一起走

HzauTriste的博客 338

LeetCode算法入门 删除链表的倒数第N个节点 解法与分析

问题描述: 给定一个链表,删除链表的倒数第 n 个节点,并且返回链表的头结点。 示例: 给定一个链表: 1->2->3->4->5, 和 n = 2. 当删除了倒数第二个节点后,链表变为 1->2->3->5. 说明: 给定的 n 保证是有效的。 进阶: 你能尝试使用一趟扫描实现吗? 解法一: 扫描两遍,第一遍知道长度,第二遍就可以删除倒数第N个结点。...

Cypress的小屋 223

链表删除倒数第N个节点:双指针与哑节点实战拆解

链表是数据结构与算法面试中的高频考点,而单链表的删除操作则是其中最容易出错的基础技能。删除某个节点,本质是让前驱节点的指针指向目标节点的后继,因此找对前驱是整个操作的关键。面对“倒数第n个节点”这类问题,常规思路是先遍历求长度再二次定位,但更高效的做法是利用快慢双指针,让快指针先走n步,再同步移动,当快指针到达链表末尾时,慢指针恰好停在待删节点的前驱位置。这一技巧不仅能实现一次遍历,还能自然处理头节点删除的边界情况。配合哑节点技术,代码逻辑更统一,健壮性更强。理解双指针的原理,不仅有助于攻克链表题,更能迁移

weixin_31102231的博客 321
上一篇: 系统架构师英语:从基础到微服务的高频术语速查
下一篇: ArkTS渲染控制全指南:if/else、ForEach与LazyForEach最佳实践
超级咨询师INFO
博客等级 码龄10年 30粉丝 1470原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值
⌂ 换网址