6327 字
约 21 分钟
10
019.删除链表的倒数第 N 个节点
2026-09-19
数据结构与算法
无标签

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

作者：沉默王二
发布时间：2024-01-31T14:56:29.219+0800

鲁迅曾说过，人生就是一个不断下楼的过程，而且每下一层楼，都会有人跟你说，这是最后一层楼了，然后你就会发现，楼层还有很多层，你还要继续下楼。嗯，LeetCode 是刷不完的，要掌握举一反三的能力。今天继续来刷《二哥的 LeetCode 刷题笔记》吧，冲鸭。

技术派阅读地址：https://paicoding.com/column/7/19

  • 语雀专栏地址+密码可通过星球置顶帖查看：https://t.zsxq.com/15rEo9Pdu

  • 这道题可以说完全重写了，给出 1道大家完全都能掌握的题解（链表）。

  • 增加代码注释，这样大家更容易看懂并掌握题解；

  • 增加参考资料，这样大家可以从零基础直接开刷，减轻新手刷题的阻力；

  • 增加手绘图，这样大家更容易理解解题思路；

  • 增加 ACM 输入输出，这样大家可以在 Intellij IDEA 中进行调试；

  • 增加题解模拟，这样大家可以根据题解模拟整个题解过程，看完会有一种“哦哦”恍然大悟的感觉；

  • 图片上传至 OSS 并配合 CDN，提升大家在技术派网站中的阅读体感。

  • 另外，这一版本会作为 PDF 的终稿随后在星球进行发布。

题意

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

难度

中等

示例

示例 1：

输入：head = [1,2,3,4,5], n = 2

示例 2：

输入：head = [1], n = 1

输入：head = [1,2], n = 1输出：[1]

进阶：你能尝试使用一趟扫描实现吗？

分析

看到这道题，其实很容易想到 LinkedList 的 remove 方法，对吧？知道 remove 方法是如何实现的，就能写出这道题的题解。

我也曾在《二哥的 Java 进阶之路 》上讲过 remove 方法的源码，其实现方式也非常简单，先遍历找到对应的节点，通过 node 方法实现，内核用的是 for 循环。

找到节点后，将节点的前一个节点的 next 指向节点的下一个节点；将节点的下一个节点的 prev 指向节点的前一个节点，这样就将节点从链表中删除了。

也就是前面提到的 unlink 方法。

LinkedList 其实比 LeetCode 这道链表的题复杂，因为 LinkedList 是双向链表，而 LeetCode 这道题是单向链表，下面是 LeetCode 为我们定义的链表 ListNode。

/**
  • public class ListNode { * int val; * ListNode next; * ListNode() {} * ListNode(int val) { this.val = val; } * ListNode(int val, ListNode next) { this.val = val; this.next = next; } * } */

把注释去掉大概就是这样子：

class ListNode {

ListNode next;	ListNode() {}	ListNode(int val) { this.val = val; }	ListNode(int val, ListNode next) { this.val = val; this.next = next; }}

两个**属性 **，或者叫成员变量、字段，一个是 val，一个是 next，val 是当前节点的值，next 是下一个节点的引用。

三个**构造方法 **，一个是无参构造方法，一个是只有 val 的构造方法，一个是 val 和 next 的构造方法。

单向链表的结构就相对简单，只有 next 没有 prev。

讲到这里，大家应该就能写出题解了。

第一步，遍历链表，找出链表的长度，确定要删除的节点的位置。

int length = 0;

while (current != null) { length++; current = current.next;}
// 找到要删除节点的前一个节点int index = length - n;

注意是倒数第 n 个节点，所以要用链表的长度减去 n。倒数第 4 个节点的前一个节点就是 5-4=1，也就是第一个节点。

第二步，遍历链表，找到要删除节点的前一个节点。

为了方便删除节点，我们需要一个虚拟节点，让虚拟节点的 next 指向 head，这样就能保证删除节点的前一个节点不为空。

ListNode dummy = new ListNode(0);

为什么？

因为当需要删除的是头节点时，操作与删除中间节点略有不同，因为没有前一个节点可以引用。引入虚拟头节点后，删除头节点和其他节点的操作可以统一处理，因为头节点也会有一个前节点（即虚拟头节点）。

当增加了虚拟节点后，要删除节点的前一个节点就是 index。

current = dummy;

current = current.next;}

第三步，找到节点后删除。

current.next=current.next.next;

也就是把要删除节点的前一个节点（current）的 next 指向要删除节点（current.next ）的下一个节点（current.next.next ）。

第四步，返回虚拟节点的 next。

return dummy.next;

OK，来看完整的题解：

class Solution {

    // 创建一个虚拟头节点，简化边界条件处理        ListNode dummy = new ListNode(0);        dummy.next = head;                // 第一次遍历，计算链表的总长度        int length = 0;        ListNode current = head;        while (current != null) {            length++;            current = current.next;        }                // 设置长度为到达要删除的节点的前一个节点        int index = length - n;        current = dummy;        // 第二次遍历，找到要删除的节点的前一个节点        for (int i = 0; i < index; i++) {            current = current.next;        }                // 删除节点，即跳过要删除的节点        current.next = current.next.next;                return dummy.next;    }}

来看一下题解的效率，beat 100%了：

很不错，如果还不理解的话，那么可以 debug 一下 ACM 模式的代码，看看每一步的执行过程。

class Main01801 {

    Solution01801 solution = new Solution01801();        ListNode head = new ListNode(1, new ListNode(2, new ListNode(3, new ListNode(4, new ListNode(5)))));        ListNode ans = solution.removeNthFromEnd(head, 4);        System.out.println(ans);    }}

class ListNode { int val; ListNode next; ListNode() {} ListNode(int val) { this.val = val; } ListNode(int val, ListNode next) { this.val = val; this.next = next; }}
class Solution01801 { public ListNode removeNthFromEnd(ListNode head, int n) { // 创建一个虚拟头节点，简化边界条件处理 ListNode dummy = new ListNode(0); dummy.next = head;
// 第一次遍历，计算链表的总长度 int length = 0; ListNode current = head; while (current != null) { length++; current = current.next; }
// 设置长度为到达要删除的节点的前一个节点 int index = length - n; current = dummy; // 第二次遍历，找到要删除的节点的前一个节点 for (int i = 0; i < index; i++) { current = current.next; }
// 删除节点，即跳过要删除的节点 current.next = current.next.next;
return dummy.next; }}

总结

链表是除了数组之外，我们接触到的另外一个数据结构，对于它的增删改查，我们必须得了如指掌，因为这俩数据结构是计算机用来存储数据单元的最基本的容器之二。

如果对链表比较陌生的话，一定要回头再看一下我在《二哥的 Java 进阶之路》中对 LinkedList 的讲解。

尤其是链表的正删改查源码，一定要掌握。当然了，这道题对理解链表的结构和删除，也会有很大的帮助。

力扣链接：https://leetcode.cn/problems/remove-nth-node-from-end-of-list/

一步一个脚印

不积跬步无以至千里，不积小流无以成江海。LeetCode - 100天从算法小白到卷王正式启动了，我们计划周一到周五至少每天更新一篇，周六周日更新一篇，目标 300 道 LeetCode 经典题。

该题解目前只针对**二哥编程星球 **的球友开放，如果你也想一起打卡学习算法的话，扫下面的优惠券加入我们吧，星球目前 4300+ 人，定价 149 元，从当初的 99 元一路涨上来的，所以早就是优势，别再犹豫了。

（优惠券仅 300 张，数量有限）

一个人可以走得很快，但一群人才能走得更远。如果想去面中大厂的话，LeetCode 几乎是必刷的，二哥的 LeetCode 题解通俗易懂、图文并茂，理解给你举一反三的解题能力，冲鸭。

鲁迅曾说过，人生就是一个不断下楼的过程，而且每下一层楼，都会有人跟你说，这是最后一层楼了，然后你就会发现，楼层还有很多层，你还要继续下楼。嗯，LeetCode 是刷不完的，要掌握举一反三的能力。今天继续来刷《二哥的 LeetCode 刷题笔记》吧，冲鸭。

技术派阅读地址：https://paicoding.com/column/7/19

  • 语雀专栏地址+密码可通过星球置顶帖查看：https://t.zsxq.com/15rEo9Pdu

  • 这道题可以说完全重写了，给出 1道大家完全都能掌握的题解（链表）。

  • 增加代码注释，这样大家更容易看懂并掌握题解；

  • 增加参考资料，这样大家可以从零基础直接开刷，减轻新手刷题的阻力；

  • 增加手绘图，这样大家更容易理解解题思路；

  • 增加 ACM 输入输出，这样大家可以在 Intellij IDEA 中进行调试；

  • 增加题解模拟，这样大家可以根据题解模拟整个题解过程，看完会有一种“哦哦”恍然大悟的感觉；

  • 图片上传至 OSS 并配合 CDN，提升大家在技术派网站中的阅读体感。

  • 另外，这一版本会作为 PDF 的终稿随后在星球进行发布。

题意

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

难度

中等

示例

示例 1：

输入：head = [1,2,3,4,5], n = 2

示例 2：

输入：head = [1], n = 1

输入：head = [1,2], n = 1输出：[1]

进阶：你能尝试使用一趟扫描实现吗？

分析

看到这道题，其实很容易想到 LinkedList 的 remove 方法，对吧？知道 remove 方法是如何实现的，就能写出这道题的题解。

我也曾在《二哥的 Java 进阶之路 》上讲过 remove 方法的源码，其实现方式也非常简单，先遍历找到对应的节点，通过 node 方法实现，内核用的是 for 循环。

找到节点后，将节点的前一个节点的 next 指向节点的下一个节点；将节点的下一个节点的 prev 指向节点的前一个节点，这样就将节点从链表中删除了。

也就是前面提到的 unlink 方法。

LinkedList 其实比 LeetCode 这道链表的题复杂，因为 LinkedList 是双向链表，而 LeetCode 这道题是单向链表，下面是 LeetCode 为我们定义的链表 ListNode。

/**
  • public class ListNode { * int val; * ListNode next; * ListNode() {} * ListNode(int val) { this.val = val; } * ListNode(int val, ListNode next) { this.val = val; this.next = next; } * } */

把注释去掉大概就是这样子：

class ListNode {

ListNode next;	ListNode() {}	ListNode(int val) { this.val = val; }	ListNode(int val, ListNode next) { this.val = val; this.next = next; }}

两个**属性 **，或者叫成员变量、字段，一个是 val，一个是 next，val 是当前节点的值，next 是下一个节点的引用。

三个**构造方法 **，一个是无参构造方法，一个是只有 val 的构造方法，一个是 val 和 next 的构造方法。

单向链表的结构就相对简单，只有 next 没有 prev。

讲到这里，大家应该就能写出题解了。

第一步，遍历链表，找出链表的长度，确定要删除的节点的位置。

int length = 0;

while (current != null) { length++; current = current.next;}
// 找到要删除节点的前一个节点int index = length - n;

注意是倒数第 n 个节点，所以要用链表的长度减去 n。倒数第 4 个节点的前一个节点就是 5-4=1，也就是第一个节点。

第二步，遍历链表，找到要删除节点的前一个节点。

为了方便删除节点，我们需要一个虚拟节点，让虚拟节点的 next 指向 head，这样就能保证删除节点的前一个节点不为空。

ListNode dummy = new ListNode(0);

为什么？

因为当需要删除的是头节点时，操作与删除中间节点略有不同，因为没有前一个节点可以引用。引入虚拟头节点后，删除头节点和其他节点的操作可以统一处理，因为头节点也会有一个前节点（即虚拟头节点）。

当增加了虚拟节点后，要删除节点的前一个节点就是 index。

current = dummy;

current = current.next;}

第三步，找到节点后删除。

current.next=current.next.next;

也就是把要删除节点的前一个节点（current）的 next 指向要删除节点（current.next ）的下一个节点（current.next.next ）。

第四步，返回虚拟节点的 next。

return dummy.next;

OK，来看完整的题解：

class Solution {

    // 创建一个虚拟头节点，简化边界条件处理        ListNode dummy = new ListNode(0);        dummy.next = head;                // 第一次遍历，计算链表的总长度        int length = 0;        ListNode current = head;        while (current != null) {            length++;            current = current.next;        }                // 设置长度为到达要删除的节点的前一个节点        int index = length - n;        current = dummy;        // 第二次遍历，找到要删除的节点的前一个节点        for (int i = 0; i < index; i++) {            current = current.next;        }                // 删除节点，即跳过要删除的节点        current.next = current.next.next;                return dummy.next;    }}

来看一下题解的效率，beat 100%了：

很不错，如果还不理解的话，那么可以 debug 一下 ACM 模式的代码，看看每一步的执行过程。

class Main01801 {

    Solution01801 solution = new Solution01801();        ListNode head = new ListNode(1, new ListNode(2, new ListNode(3, new ListNode(4, new ListNode(5)))));        ListNode ans = solution.removeNthFromEnd(head, 4);        System.out.println(ans);    }}

class ListNode { int val; ListNode next; ListNode() {} ListNode(int val) { this.val = val; } ListNode(int val, ListNode next) { this.val = val; this.next = next; }}
class Solution01801 { public ListNode removeNthFromEnd(ListNode head, int n) { // 创建一个虚拟头节点，简化边界条件处理 ListNode dummy = new ListNode(0); dummy.next = head;
// 第一次遍历，计算链表的总长度 int length = 0; ListNode current = head; while (current != null) { length++; current = current.next; }
// 设置长度为到达要删除的节点的前一个节点 int index = length - n; current = dummy; // 第二次遍历，找到要删除的节点的前一个节点 for (int i = 0; i < index; i++) { current = current.next; }
// 删除节点，即跳过要删除的节点 current.next = current.next.next;
return dummy.next; }}

总结

链表是除了数组之外，我们接触到的另外一个数据结构，对于它的增删改查，我们必须得了如指掌，因为这俩数据结构是计算机用来存储数据单元的最基本的容器之二。

如果对链表比较陌生的话，一定要回头再看一下我在《二哥的 Java 进阶之路》中对 LinkedList 的讲解。

尤其是链表的正删改查源码，一定要掌握。当然了，这道题对理解链表的结构和删除，也会有很大的帮助。

力扣链接：https://leetcode.cn/problems/remove-nth-node-from-end-of-list/

一步一个脚印

不积跬步无以至千里，不积小流无以成江海。LeetCode - 100天从算法小白到卷王正式启动了，我们计划周一到周五至少每天更新一篇，周六周日更新一篇，目标 300 道 LeetCode 经典题。

该题解目前只针对**二哥编程星球 **的球友开放，如果你也想一起打卡学习算法的话，扫下面的优惠券加入我们吧，星球目前 4300+ 人，定价 149 元，从当初的 99 元一路涨上来的，所以早就是优势，别再犹豫了。

（优惠券仅 300 张，数量有限）

一个人可以走得很快，但一群人才能走得更远。如果想去面中大厂的话，LeetCode 几乎是必刷的，二哥的 LeetCode 题解通俗易懂、图文并茂，理解给你举一反三的解题能力，冲鸭。

鲁迅曾说过，人生就是一个不断下楼的过程，而且每下一层楼，都会有人跟你说，这是最后一层楼了，然后你就会发现，楼层还有很多层，你还要继续下楼。嗯，LeetCode 是刷不完的，要掌握举一反三的能力。今天继续来刷《二哥的 LeetCode 刷题笔记》吧，冲鸭。

技术派阅读地址：https://paicoding.com/column/7/19

  • 语雀专栏地址+密码可通过星球置顶帖查看：https://t.zsxq.com/15rEo9Pdu

  • 这道题可以说完全重写了，给出 1道大家完全都能掌握的题解（链表）。

  • 增加代码注释，这样大家更容易看懂并掌握题解；

  • 增加参考资料，这样大家可以从零基础直接开刷，减轻新手刷题的阻力；

  • 增加手绘图，这样大家更容易理解解题思路；

  • 增加 ACM 输入输出，这样大家可以在 Intellij IDEA 中进行调试；

  • 增加题解模拟，这样大家可以根据题解模拟整个题解过程，看完会有一种“哦哦”恍然大悟的感觉；

  • 图片上传至 OSS 并配合 CDN，提升大家在技术派网站中的阅读体感。

  • 另外，这一版本会作为 PDF 的终稿随后在星球进行发布。

题意

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

难度

中等

示例

示例 1：

输入：head = [1,2,3,4,5], n = 2

示例 2：

输入：head = [1], n = 1

输入：head = [1,2], n = 1输出：[1]

进阶：你能尝试使用一趟扫描实现吗？

分析

看到这道题，其实很容易想到 LinkedList 的 remove 方法，对吧？知道 remove 方法是如何实现的，就能写出这道题的题解。

我也曾在《二哥的 Java 进阶之路 》上讲过 remove 方法的源码，其实现方式也非常简单，先遍历找到对应的节点，通过 node 方法实现，内核用的是 for 循环。

找到节点后，将节点的前一个节点的 next 指向节点的下一个节点；将节点的下一个节点的 prev 指向节点的前一个节点，这样就将节点从链表中删除了。

也就是前面提到的 unlink 方法。

LinkedList 其实比 LeetCode 这道链表的题复杂，因为 LinkedList 是双向链表，而 LeetCode 这道题是单向链表，下面是 LeetCode 为我们定义的链表 ListNode。

/**
  • public class ListNode { * int val; * ListNode next; * ListNode() {} * ListNode(int val) { this.val = val; } * ListNode(int val, ListNode next) { this.val = val; this.next = next; } * } */

把注释去掉大概就是这样子：

class ListNode {

ListNode next;	ListNode() {}	ListNode(int val) { this.val = val; }	ListNode(int val, ListNode next) { this.val = val; this.next = next; }}

两个**属性 **，或者叫成员变量、字段，一个是 val，一个是 next，val 是当前节点的值，next 是下一个节点的引用。

三个**构造方法 **，一个是无参构造方法，一个是只有 val 的构造方法，一个是 val 和 next 的构造方法。

单向链表的结构就相对简单，只有 next 没有 prev。

讲到这里，大家应该就能写出题解了。

第一步，遍历链表，找出链表的长度，确定要删除的节点的位置。

int length = 0;

while (current != null) { length++; current = current.next;}
// 找到要删除节点的前一个节点int index = length - n;

注意是倒数第 n 个节点，所以要用链表的长度减去 n。倒数第 4 个节点的前一个节点就是 5-4=1，也就是第一个节点。

第二步，遍历链表，找到要删除节点的前一个节点。

为了方便删除节点，我们需要一个虚拟节点，让虚拟节点的 next 指向 head，这样就能保证删除节点的前一个节点不为空。

ListNode dummy = new ListNode(0);

为什么？

因为当需要删除的是头节点时，操作与删除中间节点略有不同，因为没有前一个节点可以引用。引入虚拟头节点后，删除头节点和其他节点的操作可以统一处理，因为头节点也会有一个前节点（即虚拟头节点）。

当增加了虚拟节点后，要删除节点的前一个节点就是 index。

current = dummy;

current = current.next;}

第三步，找到节点后删除。

current.next=current.next.next;

也就是把要删除节点的前一个节点（current）的 next 指向要删除节点（current.next ）的下一个节点（current.next.next ）。

第四步，返回虚拟节点的 next。

return dummy.next;

OK，来看完整的题解：

class Solution {

    // 创建一个虚拟头节点，简化边界条件处理        ListNode dummy = new ListNode(0);        dummy.next = head;                // 第一次遍历，计算链表的总长度        int length = 0;        ListNode current = head;        while (current != null) {            length++;            current = current.next;        }                // 设置长度为到达要删除的节点的前一个节点        int index = length - n;        current = dummy;        // 第二次遍历，找到要删除的节点的前一个节点        for (int i = 0; i < index; i++) {            current = current.next;        }                // 删除节点，即跳过要删除的节点        current.next = current.next.next;                return dummy.next;    }}

来看一下题解的效率，beat 100%了：

很不错，如果还不理解的话，那么可以 debug 一下 ACM 模式的代码，看看每一步的执行过程。

class Main01801 {

    Solution01801 solution = new Solution01801();        ListNode head = new ListNode(1, new ListNode(2, new ListNode(3, new ListNode(4, new ListNode(5)))));        ListNode ans = solution.removeNthFromEnd(head, 4);        System.out.println(ans);    }}

class ListNode { int val; ListNode next; ListNode() {} ListNode(int val) { this.val = val; } ListNode(int val, ListNode next) { this.val = val; this.next = next; }}
class Solution01801 { public ListNode removeNthFromEnd(ListNode head, int n) { // 创建一个虚拟头节点，简化边界条件处理 ListNode dummy = new ListNode(0); dummy.next = head;
// 第一次遍历，计算链表的总长度 int length = 0; ListNode current = head; while (current != null) { length++; current = current.next; }
// 设置长度为到达要删除的节点的前一个节点 int index = length - n; current = dummy; // 第二次遍历，找到要删除的节点的前一个节点 for (int i = 0; i < index; i++) { current = current.next; }
// 删除节点，即跳过要删除的节点 current.next = current.next.next;
return dummy.next; }}

总结

链表是除了数组之外，我们接触到的另外一个数据结构，对于它的增删改查，我们必须得了如指掌，因为这俩数据结构是计算机用来存储数据单元的最基本的容器之二。

如果对链表比较陌生的话，一定要回头再看一下我在《二哥的 Java 进阶之路》中对 LinkedList 的讲解。

尤其是链表的正删改查源码，一定要掌握。当然了，这道题对理解链表的结构和删除，也会有很大的帮助。

力扣链接：https://leetcode.cn/problems/remove-nth-node-from-end-of-list/

一步一个脚印

不积跬步无以至千里，不积小流无以成江海。LeetCode - 100天从算法小白到卷王正式启动了，我们计划周一到周五至少每天更新一篇，周六周日更新一篇，目标 300 道 LeetCode 经典题。

该题解目前只针对**二哥编程星球 **的球友开放，如果你也想一起打卡学习算法的话，扫下面的优惠券加入我们吧，星球目前 4300+ 人，定价 149 元，从当初的 99 元一路涨上来的，所以早就是优势，别再犹豫了。

（优惠券仅 300 张，数量有限）

一个人可以走得很快，但一群人才能走得更远。如果想去面中大厂的话，LeetCode 几乎是必刷的，二哥的 LeetCode 题解通俗易懂、图文并茂，理解给你举一反三的解题能力，冲鸭。

            知识星球
            
    
    
        
        扫码加入星球
        查看更多优质内容
    
    https://wx.zsxq.com/mweb/views/joingroup/join_group.html?group_id=15522885221412
019.删除链表的倒数第 N 个节点
https://clxhxhhr.top/posts/2444/
作者
clxstart
发布于
2026-09-19
许可协议
CC BY-NC-SA 4.0
018.四数之和
020.有效的括号
评论
0 条
还没有评论，先写一条吧。