本文深入探讨python单向链表中节点删除的核心机制。删除特定索引的节点并非直接移除该节点，而是通过修改其前驱节点的`next_node`指针，使其跳过目标节点直接指向目标节点的后继节点。文章将详细解析这一过程，包括指针的定位、重新链接的逻辑，并通过代码示例和图示帮助读者理解其内部原理，确保目标节点被有效解除链接并可被垃圾回收。
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):
# 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
current_node = self.first_node
current_index = 0
# 3. 遍历到待删除节点的前一个节点 (index - 1)
# 循环条件确保 current_node 及其 next_node 存在，防止访问 NoneType 对象的属性
while current_node and current_node.next_node and current_index < (index - 1):
current_node = current_node.next_node
current_index += 1
# 4. 检查索引是否越界或待删除节点不存在
# 如果循环结束后 current_node 为 None，说明 index 超出链表长度
# 如果 current_node.next_node 为 None，说明 index 指向链表末尾之后的位置
if not current_node or not current_node.next_node:
print(f"索引 {index} 超出链表范围或节点不存在，无法删除。")
return
# 5. 执行删除操作：重新链接指针
# current_node 当前指向索引为 (index-1) 的节点（前驱节点）
# current_node.next_node 指向索引为 index 的待删除节点
# current_node.next_node.next_node 指向索引为 (index+1) 的后继节点
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(3) # 尝试删除超出范围的索引
print("删除索引 3 后 (应提示错误):")
my_list.display() # 输出: 20 -> 40 -> 50当 while current_node and current_node.next_node and current_index 前驱节点。
此时，链表的逻辑结构可以可视化为：
索引为 0 的节点 (10)
print("删除索引 0 后:")
my_list.display() # 输出: 20 -> 40 -> 50
my_list.deletion(3) # 尝试删除超出范围的索引
print("删除索引 3 后 (应提示错误):")
my_list.display() # 输出: 20 -> 40 -> 50 索引 (index-1) 索引 (index) 索引 (index+1)
↓ ↓ ↓
┌─────────────┐ ┌─────────────┐ ┌─────────────┐
│ data: 前驱 │ │ data: 待删除│ │ data: 后继 │
...───►│ next_node: ────────►│ next_node: ────────►│ next_node: ───...
└─────────────┘ └─────────────┘ └─────────────┘
^ current_node现在，我们详细分析赋值语句 current_node.next_node = current_node.next_node.next_node 的左右两边：
右侧表达式：current_node.next_node.next_node
左侧表达式：current_node.next_node 这明确表示我们希望修改 current_node（即前驱节点）的 next_node 属性。
将右侧获取到的后继节点的引用赋值给左侧，其效果就是：前驱节点 current_node 的 next_node 指针不再指向待删除节点，而是直接指向了待删除节点的后继节点。
# 假设 current_node 已经定位到待删除节点的前驱节点 node_to_delete = current_node.next_node # 1. 获取待删除节点的引用 node_after_deleted = node_to_delete.next_node # 2. 获取待删除节点的后继节点的引用 current_node.next_node = node_after_deleted # 3. 将前驱节点的 next_node 指向后继节点
经过上述操作后，链表的逻辑结构发生了变化：
索引 (index-1) 索引 (index) 索引 (index+1)
↓ ↓ ↓
┌─────────────┐ ┌─────────────┐ ┌─────────────┐
│ data: 前驱 │ │ data: 待删除│ │ data: 后继 │
...───►│ next_node: ────┐ └─────────────┘ ┌──►└─────────────┘
└─────────────┘ │ │
^ current_node └────────────────────────┘此时，待删除节点（原索引为 index 的节点）已经没有任何来自链表内部的引用指向它。这意味着它已经从链表中逻辑上移除，不再可达。Python的垃圾回收机制会在适当的时机自动回收这块不再使用的内存。