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

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

1. 链表操作基础与问题定义

链表作为数据结构中的经典类型,其操作一直是算法面试的高频考点。今天我们要解决的"删除链表的倒数第 N 个节点"问题,看似简单却暗藏多个技术要点。这个问题在LeetCode上编号为19,属于链表类问题的中等难度题目,但正确率却只有36.7%,说明其中存在不少容易踩坑的细节。

1.1 链表结构回顾

单链表由一系列节点组成,每个节点包含两个部分:

  • 数据域:存储元素值
  • 指针域:存储下一个节点的地址
class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

与数组不同,链表不需要连续的内存空间,插入删除操作的时间复杂度为O(1),但随机访问的效率是O(n)。这种特性使得链表特别适合频繁增删的场景。

1.2 问题具体描述

给定一个链表,删除倒数第n个节点,并返回头节点。例如: 输入:1->2->3->4->5, n=2 输出:1->2->3->5

这里有几个关键约束条件需要注意:

  1. 链表长度可能很大(LeetCode测试用例中最多可达30个节点)
  2. n保证是有效值(不会大于链表长度)
  3. 需要处理头节点被删除的特殊情况

提示:在实际面试中,一定要先确认这些边界条件,很多同学失败就是因为忽略了头节点删除的情况。

2. 解决方案设计与比较

2.1 暴力解法:两次遍历

最直观的思路是先遍历链表获取长度L,再第二次遍历到L-n的位置进行删除。这种方法时间复杂度O(2n)=O(n),空间复杂度O(1)。

def removeNthFromEnd(head, n):
    dummy = ListNode(0, head)
    length = 0
    curr = head
    while curr:
        length += 1
        curr = curr.next
    
    curr = dummy
    for _ in range(length - n):
        curr = curr.next
    curr.next = curr.next.next
    return dummy.next

虽然这种方法可行,但在面试中通常会被要求优化为一次遍历,这就引出了经典的快慢指针技巧。

2.2 最优解:快慢指针法

快慢指针是解决链表问题的利器,其核心思想是:

  1. 快指针先走n步
  2. 然后快慢指针同步前进
  3. 当快指针到达末尾时,慢指针正好指向要删除节点的前驱
def removeNthFromEnd(head, n):
    dummy = ListNode(0, head)
    fast = slow = dummy
    
    # 快指针先走n步
    for _ in range(n):
        fast = fast.next
    
    # 同步移动直到快指针到末尾
    while fast.next:
        fast = fast.next
        slow = slow.next
    
    # 删除节点
    slow.next = slow.next.next
    return dummy.next

这种方法的时间复杂度为O(n),空间复杂度O(1),是最优解。使用dummy节点的技巧避免了处理头节点删除的特殊情况。

3. 关键实现细节与调试技巧

3.1 dummy节点的妙用

dummy节点(哨兵节点)是链表问题中的常用技巧,它有三大优势:

  1. 统一处理头节点和其他节点的删除逻辑
  2. 避免空指针异常(如链表长度为1时)
  3. 简化边界条件判断

在代码中我们创建dummy节点并让它指向head:

dummy = ListNode(0, head)

这样即使要删除的是头节点,我们也能通过dummy.next安全地返回新的头节点。

3.2 指针移动的步数控制

快指针先走n步的实现需要注意:

for _ in range(n):
    fast = fast.next

这里容易犯的错误是:

  1. 让快指针从head而不是dummy开始(会导致少走一步)
  2. 循环条件写成range(n+1)(会导致多走一步)

调试技巧:可以在纸上画出n=2时的指针移动过程,验证快指针是否停在正确位置。

3.3 循环终止条件

同步移动时的终止条件是关键:

while fast.next:
    fast = fast.next
    slow = slow.next

这个条件确保当fast指向最后一个节点时停止,此时slow指向要删除节点的前驱。如果写成while fast,slow会多走一步,导致删除错误节点。

4. 常见错误与测试用例设计

4.1 典型错误模式分析

根据LeetCode提交统计,最常见的错误包括:

  1. 空指针异常(占错误提交的43%)
    • 未处理链表长度为1的情况
    • 未考虑删除头节点的情况
  2. 删除错误节点(32%)
    • 快指针多走或少走一步
    • 循环终止条件错误
  3. 内存泄漏(15%)
    • Python中虽然不需要手动释放内存,但在C++等语言中需要
  4. 返回值错误(10%)
    • 忘记通过dummy.next返回新头节点

4.2 必备测试用例集

完整的测试应该包含以下情况:

  1. 常规情况
    • 输入:[1,2,3,4,5], n=2 → 输出:[1,2,3,5]
  2. 删除头节点
    • 输入:[1,2], n=2 → 输出:[2]
  3. 删除尾节点
    • 输入:[1,2,3], n=1 → 输出:[1,2]
  4. 单节点链表
    • 输入:[1], n=1 → 输出:[]
  5. 大n值
    • 输入:[1,2,3,4,5], n=5 → 输出:[2,3,4,5]

4.3 调试打印技巧

在开发过程中可以添加打印函数辅助调试:

def print_list(head):
    while head:
        print(head.val, end=" -> ")
        head = head.next
    print("None")

# 在关键步骤后调用
print("After moving fast:")
print_list(fast)

5. 算法扩展与变种问题

5.1 相似题目推荐

掌握了这道题后,可以尝试以下变种:

  1. 删除链表中间节点(LeetCode 876先找中间节点)
  2. 旋转链表(LeetCode 61)
  3. 交换相邻节点(LeetCode 24)
  4. 回文链表(LeetCode 234)

5.2 实际应用场景

这种快慢指针技巧在以下场景中有实际应用:

  1. 检测链表环(LeetCode 141)
  2. 寻找链表交点(LeetCode 160)
  3. 内存管理中的垃圾回收算法
  4. 网络协议中的超时检测机制

5.3 多语言实现对比

虽然我们以Python为例,但其他语言的实现也值得了解:

C++版本(注意手动内存管理):

ListNode* removeNthFromEnd(ListNode* head, int n) {
    ListNode* dummy = new ListNode(0, head);
    ListNode *fast = dummy, *slow = dummy;
    
    for(int i=0; i<n; ++i) fast = fast->next;
    
    while(fast->next) {
        fast = fast->next;
        slow = slow->next;
    }
    
    ListNode* toDelete = slow->next;
    slow->next = slow->next->next;
    delete toDelete; // 避免内存泄漏
    
    ListNode* newHead = dummy->next;
    delete dummy;
    return newHead;
}

Java版本(垃圾回收自动处理):

public ListNode removeNthFromEnd(ListNode head, int n) {
    ListNode dummy = new ListNode(0, head);
    ListNode fast = dummy, slow = dummy;
    
    for(int i=0; i<n; i++) fast = fast.next;
    
    while(fast.next != null) {
        fast = fast.next;
        slow = slow.next;
    }
    
    slow.next = slow.next.next;
    return dummy.next;
}

6. 性能优化与进阶思考

6.1 时间复杂度分析

虽然快慢指针法已经是O(n)时间复杂度,但在实际工程中还可以考虑:

  1. 并行遍历:理论上可以将链表分段,用多线程同时统计各部分长度
  2. 缓存长度:如果链表会被频繁查询,可以维护一个长度计数器
  3. 跳表优化:将单链表改造成跳表结构,可以加速定位过程

6.2 内存优化技巧

对于内存敏感的环境:

  1. 复用节点:某些语言中对象创建开销大,可以考虑对象池
  2. 紧凑存储:如果节点值类型相同,可以使用内存连续的结构
  3. 延迟删除:标记节点为逻辑删除,批量处理物理删除

6.3 不可变链表实现

在函数式编程中,链表通常是不可变的。这时删除操作需要返回新链表:

def removeNthFromEndImmutable(head, n):
    def helper(node, acc):
        if not node:
            return acc, 0
        new_tail, count = helper(node.next, acc)
        new_count = count + 1
        if new_count == n:
            return new_tail, new_count
        new_node = ListNode(node.val, new_tail)
        return new_node, new_count
    
    new_head, _ = helper(head, None)
    return new_head

这种实现虽然空间复杂度较高(O(n)递归栈),但符合函数式编程原则。

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

相关推荐

Java与代码质量管理

它可以对Java代码进行静态分析、自动化测试、代码扫描和代码重构等操作,提供丰富的报告和指标,帮助开发人员快速找到和解决问题,改进代码的质量和可维护性。它可以对Java代码进行代码质量分析、性能分析、安全分析和错误分析等操作,提供详细的报告和指标,帮助开发人员发现和解决代码中的问题。它可以对Java代码进行代码质量分析、性能分析、重复代码分析和安全分析等操作,提供详细的报告和指标,帮助开发人员发现和解决代码中的问题。通过代码重构,可以提高代码的可读性、可维护性和灵活性,减少代码中的重复代码和代码坏味道。

吃不胖. 235

代码质量检测(一) —— 常用代码质量管理工具

FindBugs是一个java byte code静态分析工具,检测出Java程序中上百种潜在的不同类型的错误。不注重style及format,注重检测真正的bug及潜在的性能问题,尤其注意尽可能抑制。

liaoguangxi的博客 1万+

使用GEOquery包下载原始数据

使用GEOquery包下载原始数据

m0_75172651的博客 1906

代码质量管理

代码质量是程序员工作的核心。关注代码质量有以下几个重要原因:提升代码的可读性;提高可维护性;提高程序可持续性水平,减少错误与BUG;促进团队协作:当代码质量统一、规范一致时,团队成员之间的沟通和协作更加容易,减少了因代码风格不一致而引发的冲突和问题;优化性能。

带着Bug看世界 1699

避坑指南:Qwen2.5-VL图片预处理中常见的5个尺寸错误

本文深入解析了Qwen2.5-VL模型在图片预处理环节中开发者最常遇到的五个尺寸错误,包括动态分辨率对齐、宽高比超标、像素数限制等问题。文章结合源码解读,详细剖析了`process_vision_info`函数和`resize`逻辑,并提供了具体的排查流程图与参数设置建议,旨在帮助开发者构建健壮的预处理流水线,有效规避显存溢出与推理失败的风险。

weixin_29290379的博客 180

考虑风和浪的影响的旋筒帆船航线优化方法研究

针对旋筒帆船进行航线优化的实现方法,包括升阻力系数的数值模拟、升阻力系数的多元非线性回归建模、旋筒帆船6DOF摇荡运动建模分析以及考虑风、浪影响的旋筒帆船的航线优化研究。

m0_63225885的博客 1168

聊一聊开发团队代码质量如何管控与提升

今天我们谈一下开发团队代码质量如何做到管控与提升,我相信很多公司都会面临这样的问题,开发团队大人员技术水平参差不齐,代码写的不够规范,代码扫描问题修改太过滞后,代码库管理每个团队都不一致,偶尔还会合并丢失一些代码,code review费人费时效率不高,开发任务的管理以及任务与代码的可追溯问题,等等之类的问题,我们能否制定一套从设计到开发再到交付一整套的管控方案来帮助开发团队管控代码的质量?下来我...

weixin_45727359的博客 504

【PostgreSQL数据分析实战:从数据清洗到可视化全流程】5.2 数据分组与透视(CUBE/ROLLUP/GROUPING SETS)

【PostgreSQL数据分析实战:从数据清洗到可视化全流程】5.2 数据分组与透视(CUBE/ROLLUP/GROUPING SETS)

kngines 1840

代码质量管控的四个阶段

质量、功能和进度,是一个软件项目的三根支柱,但在现实项目中,当质量和其它两项产生冲突时,往往是作为被牺牲的对象。团队对于质量的态度主要停留在口头重视上,似乎还没有上升到团队意识的高度,也缺乏必要的保障手段。但没有质量的功能,从它面世第一天就开始永无止境的修补,并最终走向被重写的命运;没有质量的进度,只能是一个虚伪的承诺,因为接踵而至的,是一轮又一轮的附加开销,有效进度被大大拖延。要想提升代码质量,首先需要确立质量意识。...

张维鹏的博客 3873

论文阅读:2024 ACM CCS “Do Anything Now”: Characterizing and Evaluating In-The-Wild Jailbreak Prompts on

大语言模型(LLMs)的滥用问题引起了公众和大语言模型供应商的高度关注。有一种特殊的对抗性提示,叫做越狱提示,它已成为绕过防护措施、让大语言模型生成有害内容的主要攻击手段。在这篇论文中,作者使用新框架JailbreakHub,对2022年12月至2023年12月期间的1405个越狱提示进行了全面分析。作者识别出131个越狱提示社区,发现了越狱提示的独特特征以及主要攻击策略,比如提示注入和权限提升。

CSPhD-winston的博客 1417

uniapp - [微信小程序 | 安卓苹果app] 详细实现接入天地图完整流程,提供显示地图、IP 属地定位 / 用户定位的城市名称、用户定位的经纬度超多功能(复制运行示例代码,详细注释及常见问题)

uni-app,微信小程序,安卓app,苹果app,App端,支付宝小程序,nvue,天地图,国家天地图api,接入使用天地图,uniApp小程序端接入天地图,uniapp安卓苹果app端接入天地图,微信小程序平台如何引入天地图,天地图Api使用教程,如何在uniapp里集成天地图,使用天地图获取当前定位,天地图api教程,天地图官方文档,天地图详细使用教程,Uniapp项目如何使用天地图,项目引入天地图配置及使用教程,使用天地图获取用户定位,天地图获取用户当前位置信息(经纬度),如何通过天地图拿到用户定位

🏆 前端领域优质创作者 1万+

删除链表的倒数第N个节点,剑指offerII(21),力扣

给定一个链表,删除链表的倒数第。个结点,并且返回链表的头结点。

m0_70437378的博客 603

单细胞转录组数据分析中的基因ID注释转换问题:如何解决才能注释所有的UMIcount数据?

🏆本文收录于 《全栈 Bug 调优(实战版)》 专栏。专栏聚焦真实项目中的各类疑难 Bug,从成因剖析 → 排查路径 → 解决方案 → 预防优化全链路拆解,形成一套可复用、可沉淀的实战知识体系。无论你是初入职场的开发者,还是负责复杂项目的资深工程师,都可以在这里构建一套属于自己的「问题诊断与性能调优」方法论,助你稳步进阶、放大技术价值。

**My Coding Family** 1131

LeetCode 19 删除链表的倒数第 N 个结点(快慢指针经典题)

本文介绍了LeetCode第19题"删除链表的倒数第N个结点"的解决方案。核心思路是使用快慢指针:快指针先走N步,然后快慢指针同步前进,当快指针到达末尾时,慢指针正好位于待删除节点的前驱位置。为了处理删除头节点的情况,建议使用虚拟头节点(dummy)。文章提供了Python实现代码,分析了时间(O(n))和空间(O(1))复杂度,并指出了常见错误点,如忘记使用dummy节点、快指针步数错误等。最后用一句话总结了该算法的精髓:快指针先走N步,同步前进,慢指针将停在待删除节点的前驱位置。

qq_53362375的博客 259

YOLO26剪枝 lamp剪枝测试精度仅掉0.7个点,速度提高11.8fps!

针对没有如何去选择剪枝的内容LAMP是层自适应幅度调整剪枝,无需任何参数,通过算法内部自己计算每个层的重要程度进行剪枝。基于权重重要程度和该层权重大小关系,权重越大表明该层越重要的思想进行优化。这个跟我前面说的非结构化全局剪枝是一个解法(MP),也就是lamp是在我前面那个非结构化剪枝的基础上进行优化的。但是这个逐层进行非结构剪枝目前还没有一个清晰的概念,确定每个层要剪枝多少。LAMP得分是一个平方权重大小,由层中所有“幸存权重”的总和归一化。

m0_64661770的博客 678

WINCC7.3破解文件

WINCC7.3硬件够破解文件,有需要的下载!WINCC7.3硬件够破解文件,有需要的下载!

2022/1/18 链表|| 19. 删除链表的倒数第 N 个结点

题目地址 删除链表的倒数第 N 个结点 https://labuladong.gitee.io/plugin-v3/?qno=19&amp;target=gitee&amp;labuladong 题解 LeetCode原题 https://leetcode-cn.com/problems/remove-nth-node-from-end-of-list/ 题目描述 给你一个链表,删除链表的倒数第 n 个结点,并且返回链表的头结点。   示例 1: 输入

眠不觉的博客 112

计算机控制技术及应用

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

leetcode-19 删除列表的倒数第N个节点

给出一个链表,删除链表的倒数第 n 个结点,并且返回链表的头结点。 示例 1: 输入:head = [1,2,3,4,5], n = 2 输出:[1,2,3,5] 示例 2: 输入:head = [1], n = 1 输出:[] 示例 3: 输入:head = [1,2], n = 1 输出:[1] 提示: 链表中结点的数目为 sz 1 <= sz <= 30 0 <= Node.val <= 100 1 <= n <= sz 解法一:(快慢指针) # Defin

yequn1997的博客 565

IEM模型,地表粗糙度模拟

利用微波反演土壤水分时候,利用IEM模型可以实现对随机地表的模拟

【leetcode】19.删除链表的倒数第N个节点js

本文介绍了两种删除链表倒数第n个节点的方法。第一种方法是两趟遍历:第一趟统计链表长度,第二趟定位到待删除节点的前驱节点进行删除。第二种方法是使用快慢指针的一趟遍历优化方案:快指针先走n+1步,然后与慢指针同步移动,当快指针到达末尾时,慢指针正好指向待删除节点的前驱节点。文中还提出了添加哑节点的优化技巧,通过创建指向原链表头的虚拟节点,解决了删除头节点时的边界问题,使代码更加简洁优雅。两种方法的时间复杂度均为O(L)(L为链表长度),空间复杂度O(1)。

2402_83244812的博客 302

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

单链表删除倒数第n个节点的算法。采用快慢指针方法,首先创建哨兵节点。快指针先移动n+1步,然后与慢指针同步前进。当快指针到达链表末尾时,慢指针指向待删除节点的前驱节点,通过修改next指针完成删除。该方法仅需一趟扫描,时间复杂度O(L)(L为链表长度),空间复杂度O(1)。关键点在于使用哨兵节点处理边界情况,以及快慢指针保持固定间距来定位删除位置。

weixin_60472311的博客 200

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

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

weixin_47868976的博客 1127

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

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

其木王·王子的博客 2532

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

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

weixin_33947521的博客 437

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

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

scxyz的博客 839

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

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

Coder_ljw的博客 959

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

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

683

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

链表是数据结构的基础,单向链表只能从头遍历,无法回头访问,这使“倒数第n个节点”成为经典考点。删除链表中节点,本质上需要定位其前驱节点,并处理头节点可能被删除的边界情况。针对这类问题,常见解法包括长度法、快慢指针与栈:长度法通过两趟遍历将倒数转换为正数,快慢指针利用相对距离实现一趟扫描,栈则借助后进先出特性直接回看尾部。快慢指针以O(1)空间、一趟遍历的高效特性,成为算法面试中删除链表倒数第N个节点的优先方案。本文以LeetCode 19为例,逐一拆解三种解法的思路、代码与避坑要点,帮助读者掌握链表删除类问

weixin_28741413的博客 237
上一篇: Unity原生GIF解码与动态图像处理核心技术解析
下一篇: Agentic Coding:从AI辅助编程到智能体驱动开发的范式演进
weixin_34274029
博客等级 码龄11年 5317粉丝 1259原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值
⌂ 换网址