本文深入探讨Python单链表中节点的删除机制，重点阐述如何通过修改前驱节点的`next_node`指针来实现目标节点的移除。文章将详细解析`current_node.next_node = current_node.next_node.next_node`这行关键代码的逻辑，并通过示例代码和图示，帮助读者理解单链表删除操作的核心原理，包括边界情况处理和内存回收概念。
在数据结构中，链表是一种重要的线性结构，与数组不同，它不依赖于内存的连续性。单链表中的每个节点只包含数据和指向下一个节点的指针。这种特性使得链表的插入和删除操作在理论上比数组更高效（无需移动大量元素），但其实现方式也需要对指针操作有清晰的理解。本文将专注于Python中单链表节点的删除方法，特别是对核心逻辑的深入剖析。
在单链表中删除一个节点，本质上是修改其前一个节点的next_node指针，使其跳过目标节点，直接指向目标节点的下一个节点。被跳过的节点将不再被链表引用，最终会被垃圾回收机制处理。
为了更好地理解删除操作，我们首先需要定义链表节点和链表类。
立即学习“Python免费学习笔记（深入）”；
一个基本的链表节点通常包含两部分：数据（data）和指向下一个节点的指针（next_node）。
class Node:
def __init__(self, data):
self.data = data
self.next_node = None链表类通常包含一个指向链表头部的指针（first_node）。
class LinkedList:
def __init__(self):
self.first_node = None
def append(self, data):
new_node = Node(data)
if not self.first_node:
self.first_node = new_node
return
current = self.first_node
while current.next_node:
current = current.next_node
current.next_node = new_node
def display(self):
elements = []
current = self.first_node
while current:
elements.append(current.data)
current = current.next_node
print(" -> ".join(map(str, elements)))现在，我们来详细分析单链表的删除方法。该方法接受一个index参数，表示要删除的节点位置（从0开始计数）。
class LinkedList:
# ... (previous Node and LinkedList init/append/display methods) ...
def deletion(self, index):
# 1. 处理链表为空的情况
if not self.first_node:
print("链表为空，无法删除。")
return
# 2. 处理删除第一个节点（index = 0）的情况
if index == 0:
self.first_node = self.first_node.next_node
print(f"已删除索引 {index} 处的节点。")
return
# 3. 处理删除非第一个节点的情况
current_node = self.first_node
current_index = 0
# 找到目标节点的前一个节点
# 循环结束后，current_node 将指向待删除节点的前一个节点
while current_node and current_index < (index - 1):
current_node = current_node.next_node
current_index += 1
# 检查索引是否越界或current_node是否为None (即index-1不存在)
if not current_node or not current_node.next_node:
print(f"索引 {index} 超出链表范围或目标节点不存在。")
return
# 核心删除逻辑：修改前驱节点的next_node指针
current_node.next_node = current_node.next_node.next_node
print(f"已删除索引 {index} 处的节点。")这行代码是理解单链表删除的关键。让我们通过一个例子来逐步解析：假设我们要删除索引为 3 的节点。
找到前驱节点： 在while current_index
我们可以用下图表示此时的状态：
索引 2 索引 3 索引 4
(current_node)
↓
┌─────────────┐ ┌─────────────┐ ┌─────────────┐
...───►│ data: 10 │──────►│ data: 20 │──────►│ data: 30 │───...
│ next_node: ────────►│ next_node: ────────►│ next_node: ───...
└─────────────┘ └─────────────┘ └─────────────┘解析赋值语句的右侧：current_node.next_node.next_node
简而言之，current_node.next_node.next_node 最终指向的是目标节点（索引 3）的下一个节点（索引 4）。
执行赋值语句：current_node.next_node = ... 这条语句将 current_node (索引 2 的节点) 的 next_node 指针，从原来的指向索引 3 的节点，改为指向索引 4 的节点。
执行后的状态如下：
索引 2 索引 4
(current_node)
↓
┌─────────────┐ ┌─────────────┐ ┌─────────────┐
...───►│ data: 10 │───────┐ data: 20 │──────►│ data: 30 │───...
│ next_node: ───────┐ │ next_node: ────────►│ next_node: ───...
└─────────────┘ │ └─────────────┘ ┌──►└─────────────┘
└───────────────────┘现在，索引为 2 的节点直接指向了索引为 4 的节点，索引为 3 的节点（数据 20）不再被链表中的任何节点引用。
为了进一步明确，可以将这行代码分解为多个步骤：
# current_node 已经指向待删除节点的前一个节点 node_to_delete = current_node.next_node # 获取待删除节点的引用 (索引 3) node_after_deleted = node_to_delete.next_node # 获取待删除节点之后节点的引用 (索引 4) current_node.next_node = node_after_deleted # 将前驱节点的指针指向待删除节点之后的节点
通过这种方式，我们清晰地看到，链表的逻辑结构中已经“跳过”了索引为 3 的节点。
一旦 current_node.next_node = current_node.next_node.next_node 执行完毕，被删除的节点（即原先 current_node.next_node 所指向的节点）将不再有任何来自链表内部的引用。在Python中，这意味着该节点对象将成为垃圾回收器（Garbage Collector）的候选。垃圾回收器会在适当的时候自动释放该节点所占用的内存，无需我们手动管理。
下面是一个包含 Node 和 LinkedList 类的完整实现，以及删除操作的演示：
class Node:
def __init__(self, data):
self.data = data
self.next_node = None
class LinkedList:
def __init__(self):
self.first_node = None
def append(self, data):
new_node = Node(data)
if not self.first_node:
self.first_node = new_node
return
current = self.first_node
while current.next_node:
current = current.next_node
current.next_node = new_node
def display(self):
elements = []
current = self.first_node
while current:
elements.append(current.data)
current = current.next_node
print(" -> ".join(map(str, elements)))
def deletion(self, index):
if not self.first_node:
print("链表为空，无法删除。")
return
if index == 0:
self.first_node = self.first_node.next_node
print(f"已删除索引 {index} 处的节点。")
return
current_node = self.first_node
current_index = 0
# 找到目标节点的前一个节点
while current_node and current_index < (index - 1):
current_node = current_node.next_node
current_index += 1
# 检查索引是否越界或目标节点不存在
if not current_node or not current_node.next_node:
print(f"索引 {index} 超出链表范围或目标节点不存在。")
return
# 核心删除逻辑
current_node.next_node = current_node.next_node.next_node
print(f"已删除索引 {index} 处的节点。")
# 演示
my_list = LinkedList()
my_list.append(10)
my_list.append(20)
my_list.append(30)
my_list.append(40)
my_list.append(50)
print("原始链表:")
my_list.display() # 输出: 10 -> 20 -> 30 -> 40 -> 50
my_list.deletion(2) # 删除索引为 2 的节点 (30)
print("删除索引 2 后的链表:")
my_list.display() # 输出: 10 -> 20 -> 40 -> 50
my_list.deletion(0) # 删除索引为 0 的节点 (10)
print("删除索引 0 后的链表:")
my_list.display() # 输出: 20 -> 40 -> 50
my_list.deletion(10) # 尝试删除不存在的索引
print("尝试删除不存在索引后的链表:")
my_list.display() # 输出: 20 -> 40 -> 50
my_list.deletion(2) # 删除索引为 2 的节点 (50)
print("删除索引 2 后的链表:")
my_list.display() # 输出: 20 -> 40
my_list.deletion(0) # 删除索引为 0 的节点 (20)
my_list.deletion(0) # 删除索引为 0 的节点 (40)
my_list.deletion(0) # 尝试删除空链表边界条件处理： 在实现删除操作时，务必考虑以下边界情况：
单链表的局限性： 由于单链表只能单向遍历，删除一个节点必须先找到它的前驱节点。这意味着，如果只给定一个要删除的节点本身的引用，而不知道其前驱节点，则无法直接删除它（除非从头遍历）。双向链表则没有这个限制，因为每个节点都有指向前一个节点的指针。
时间复杂度： 单链表删除操作的时间复杂度为 O(n)，其中 n 是链表的长度。这是因为在最坏情况下（删除最后一个节点），我们需要从头遍历到目标节点的前一个节点。
通过本文的详细解析，相信读者对Python单链表删除操作的原理和实现有了更深入的理解，特别是对current_node.next_node = current_node.next_node.next_node这一核心语句的含义和作用有了清晰的认识。掌握这些基础知识对于进一步学习和应用更复杂的数据结构至关重要。
以上就是Python单链表删除操作深度解析的详细内容，更多请关注php中文网其它相关文章！
每个人都需要一台速度更快、更稳定的 PC。随着时间的推移，垃圾文件、旧注册表数据和不必要的后台进程会占用资源并降低性能。幸运的是，许多工具可以让 Windows 保持平稳运行。
广告Copyright 2014-2025 https://www.php.cn/ All Rights Reserved | php.cn | 湘ICP备2023035733号
673
收藏
