Python单链表节点删除深度解析：理解指针重定向的机制

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 deletion(self, index):
        # 检查链表是否为空
        if not self.first_node:
            print("链表为空，无法删除。")
            return

        current_node = self.first_node
        current_index = 0

        # 处理删除第一个节点（索引为0）的特殊情况
        if index == 0:
            self.first_node = self.first_node.next_node
            return

        # 遍历链表，找到待删除节点的前一个节点
        # 循环结束后，current_node 将指向索引为 (index - 1) 的节点
        while current_index < (index - 1):
            # 如果在找到前驱节点之前，链表已经结束，说明索引超出范围
            if not current_node.next_node:
                print(f"索引 {index} 超出链表范围，无法删除。")
                return
            current_node = current_node.next_node
            current_index += 1

        # 再次检查，确保待删除节点存在
        if not current_node.next_node:
            print(f"索引 {index} 超出链表范围，无法删除。")
            return

        # 执行删除操作：重定向指针
        # current_node.next_node 指向待删除节点
        # current_node.next_node.next_node 指向待删除节点的后继节点
        current_node.next_node = current_node.next_node.next_node

    def display(self):
        elements = []
        current = self.first_node
        while current:
            elements.append(current.data)
            current = current.next_node
        print(" -> ".join(map(str, elements)))

# 示例使用
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(2) # 删除索引为2的节点 (50)
print("删除索引2后的链表:")
my_list.display() # 输出: 20 -> 40

my_list.deletion(10) # 尝试删除超出范围的索引

           index-1               index                 index+1
       current_node
          ↓
       ┌─────────────┐       ┌─────────────┐       ┌─────────────┐
       │ data: ...   │       │ data: ...   │       │ data: ...   │
...───►│ next_node: ────────►│ next_node: ────────►│ next_node: ───...
       └─────────────┘       └─────────────┘       └─────────────┘

           index-1               index                 index+1
       current_node
          ↓
       ┌─────────────┐       ┌─────────────┐       ┌─────────────┐
       │ data: ...   │       │ data: ...   │       │ data: ...   │
...───►│ next_node: ────┐    │ next_node: ────────►│ next_node: ───...
       └─────────────┘  │    └─────────────┘   ┌──►└─────────────┘
                        └──────────────────────┘

# 1. 获取待删除节点
node_to_delete = current_node.next_node

# 2. 获取待删除节点的后继节点
node_after_deleted = node_to_delete.next_node

# 3. 将前驱节点的next_node指向后继节点
current_node.next_node = node_after_deleted