1. 题目
描述
给定一个链表，删除链表的倒数第 n 个节点并返回链表的头指针 例如，
给出的链表为: 1→2→3→4→5, n= 2. 删除了链表的倒数第 n 个节点之后,链表变为1→2→3→5.
数据范围： 链表长度 0≤n≤1000，链表中任意节点的值满足 0≤val≤100
要求：空间复杂度 O(1)，时间复杂度 O(n) 备注：
题目保证 n 一定是有效的
示例1
输入： {1,2},2
返回值： {2}
2. 解题思路
删除链表的倒数第n个节点，需要先找到倒数第n个节点的前一个节点，之后再更改前一个节点的指针域，让它指向下下一个节点，这样就可以将倒数第n个节点删除。快速查找倒数第n个节点可以参考上一篇的内容《可视化图解算法：链表中倒数（最后）k个结点》。
假如要删除的链表结构如下图所示，给定的n=2。即需删除倒数第2个节点，也就是4节点。
我们可以采用以下步骤完成倒数第2个节点的删除：
步骤一：定义快慢指针。
步骤二：移动快指针。
快指针移动n次，每次移动一个节点。
步骤三：快慢指针一起移动。
移动快慢指针（条件是：快指针指向节点的下一个节点为Null）。
步骤四：执行删除节点操作。
slow.next=slow.next.next
步骤五：特殊情况处理。
如果要删除的是头节点，如以下链表，给定的n=2。
特殊情况的判断是：快指针移动n步之后，已经指向了Null。
这时，直接返回头节点的下一个节点即可（原头节点删除，返回新的头节点）。
如果文字描述的不太清楚，你可以参考视频的详细讲解。
- Python版本：www.bilibili.com/cheese/play…
- Java版本：www.bilibili.com/cheese/play…
- Golang版本：www.bilibili.com/cheese/play…
3. 编码实现
3.1 Python编码实现
class ListNode:
def __init__(self, x):
self.val = x # 链表的数值域
self.next = None # 链表的指针域
# 从链表节点尾部添加节点
def insert_node(node, value):
if node is None:
print("node is None")
return
# 创建一个新节点
new_node = ListNode(value)
cur = node
# 找到链表的末尾节点
while cur.next is not None:
cur = cur.next
# 末尾节点的next指针域连接新节点
cur.next = new_node
# 打印链表（从链表头结点开始打印链表的值）
def print_node(node):
cur = node
# 遍历每一个节点
while cur is not None:
print(cur.val, end="\t")
cur = cur.next # 更改指针变量的指向
print()
#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
#
# @param head ListNode类
# @param n int整型
# @return ListNode类
#
class Solution:
def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:
# write code here
if head is None:
return head
# 1. 定义快慢指针
fast = head
slow = head
# 2. 移动快指针
for i in range(n):
fast = fast.next
# 3. 特殊情况判断：是否删除的是头节点
if fast is None:
return head.next
# 4.对于一般情况，移动快慢指针（条件是：快指针指向节点的下一个节点为None）
while fast.next is not None:
fast = fast.next
slow = slow.next
# 5. 执行删除节点操作
slow.next = slow.next.next
return head
if __name__ == '__main__':
head = ListNode(1)
insert_node(head, 2)
insert_node(head, 3)
insert_node(head, 4)
insert_node(head, 5)
print_node(head)
s = Solution()
node = s.removeNthFromEnd(head, 2)
print_node(node)
root = ListNode(1)
insert_node(root, 2)
print_node(root)
node1 = s.removeNthFromEnd(root, 2)
print_node(node1)
3.2 Java编码实现
package LL09;
public class Main {
//定义链表节点
static class ListNode {
private int val; //链表的数值域
private ListNode next; //链表的指针域
public ListNode(int data) {
this.val = data;
this.next = null;
}
}
//添加链表节点
private static void insertNode(ListNode node, int data) {
if (node == null) {
return;
}
//创建一个新节点
ListNode newNode = new ListNode(data);
ListNode cur = node;
//找到链表的末尾节点
while (cur.next != null) {
cur = cur.next;
}
//末尾节点的next指针域连接新节点
cur.next = newNode;
}
//打印链表（从头节点开始打印链表的每一个节点）
private static void printNode(ListNode node) {
ListNode cur = node;
//遍历每一个节点
while (cur != null) {
System.out.print(cur.val + "\t");
cur = cur.next; //更改指针变量的指向
}
System.out.println();
}
public static class Solution {
/**
* 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
*
* @param head ListNode类
* @param n int整型
* @return ListNode类
*/
public ListNode removeNthFromEnd(ListNode head, int n) {
// write code here
if (head == null) {
return head;
}
// 1. 定义快慢指针
ListNode fast = head;
ListNode slow = head;
// 2. 移动快指针
for (int i = 0; i < n; i++) {
fast = fast.next;
}
// 3. 特殊情况判断：是否删除的是头节点
if (fast == null) {
return head.next;
}
// 4. 对于一般情况，移动快慢指针（条件是：快指针指向节点的下一个节点为null）
while (fast.next != null) {
fast = fast.next;
slow = slow.next;
}
// 5. 执行删除节点操作
slow.next = slow.next.next;
return head;
}
}
public static void main(String[] args) {
ListNode head = new ListNode(1);
insertNode(head, 2);
insertNode(head, 3);
insertNode(head, 4);
insertNode(head, 5);
printNode(head);
Solution solution = new Solution();
ListNode node = solution.removeNthFromEnd(head, 2);
printNode(node);
ListNode root = new ListNode(1);
insertNode(root, 2);
printNode(root);
ListNode node1 = solution.removeNthFromEnd(root, 2);
printNode(node1);
}
}
3.3 Golang编码实现
package main
import "fmt"
// ListNode 定义链表节点
type ListNode struct {
Val int //链表的数值域
Next *ListNode //链表的指针域
}
/**
* 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
*
*
* @param head ListNode类
* @param n int整型
* @return ListNode类
*/
func removeNthFromEnd(head *ListNode, n int) *ListNode {
// write code here
if head == nil {
return head
}
// 1. 定义快慢指针
fast := head
slow := head
// 2. 移动快指针
for i := 0; i < n; i++ {
//不存在：fast==nil。题目要求：n是有效的，即：n<=链表的长度，此种情况不存在
fast = fast.Next
}
// 3. 特殊情况判断：是否删除的是头节点
if fast == nil {
return head.Next
}
// 4. 对于一般情况，移动快慢指针（条件是：快指针指向节点的下一个节点为nil）
for fast.Next != nil {
fast = fast.Next
slow = slow.Next
}
// 5. 执行删除节点操作
slow.Next = slow.Next.Next
return head
}
func main() {
head := ListNode{Val: 1}
head.Insert(2)
head.Insert(3)
head.Insert(4)
head.Insert(5)
head.Print()
node := removeNthFromEnd(&head, 2)
node.Print()
root := ListNode{Val: 1}
root.Insert(2)
root.Print()
node1 := removeNthFromEnd(&root, 2)
node1.Print()
}
// Insert 从链表节点尾部添加节点
func (ln *ListNode) Insert(val int) {
if ln == nil {
return
}
//创建一个新节点
newNode := &ListNode{Val: val}
cur := ln
//找到链表的末尾节点
for cur.Next != nil {
cur = cur.Next
}
//末尾节点的next指针域连接新节点
cur.Next = newNode
}
// Print 从链表头结点开始打印链表的值
func (ln *ListNode) Print() {
if ln == nil {
return
}
cur := ln
//遍历每一个节点
for cur != nil {
fmt.Print(cur.Val, "\t")
cur = cur.Next //更改指针变量的指向
}
fmt.Println()
}
如果上面的代码理解的不是很清楚，你可以参考视频的详细讲解。
- Python版本：www.bilibili.com/cheese/play…
- Java版本：www.bilibili.com/cheese/play…
- Golang版本：www.bilibili.com/cheese/play…
4.小结
删除链表的倒数第n个节点 ，可以通过以下步骤完成：（1）定义快慢指针；（2）移动快指针；（3）快慢指针一起移动；（4）执行删除节点操作；（5）特殊情况处理。难点是很容易忽略特殊情况的处理。
更多算法视频讲解，你可以从以下地址找到：
- Python编码实现：www.bilibili.com/cheese/play…
- Java编码实现：www.bilibili.com/cheese/play…
- Golang编码实现：www.bilibili.com/cheese/play…
对于链表的相关操作，我们总结了一套【可视化+图解】方法，依据此方法来解决链表相关问题，链表操作变得易于理解，写出来的代码可读性高也不容易出错。具体也可以参考视频详细讲解。
今日佳句：竹外桃花三两枝，春江水暖鸭先知。
