链表相关知识及python代码实现

Ne0inhk

26 Mar 2026 — 21 min read

第一部分：基本含义

链表（Linked List）是一类很经典的线性数据结构：数据不是连续存放在一整块内存里，而是由一个个“节点”组成，每个节点除了存数据（value），还会保存指向下一个（或上一个）节点的引用/指针。它的核心特点就是：靠指针把元素串起来。

第二部分：基本结构

链表的最小单元是「节点」，任何链表的节点都必须包含这两个核心成员：

数据域：存储当前节点的有效数据（比如数字、字符串、对象等）；
指针域：存储「下一个节点的内存地址」（Java/Python 中叫「引用」），作用是指向下一个节点，把零散的节点串联起来。

（1）单链表

每个节点只知道“下一个是谁”：
head -> node1 -> node2 -> ... -> null

优点：结构简单、插入删除方便
缺点：不能反向遍历；找前驱节点麻烦

【头节点】 → 【数据域：10 | 指针域→】 → 【数据域：20 | 指针域→】 → 【数据域：30 | 指针域：null】

整个链表有一个头节点（Head），是链表的入口，我们所有操作都从头部开始；
链表的最后一个节点，指针域的值是 null（空），表示链表到此结束；
链表只能从头节点开始，顺着指针一个一个往后遍历，无法像数组一样随机访问。

（2）双向链表

每个节点知道前后是谁：
null <- node1 <-> node2 <-> ... -> null

优点：能双向遍历；删除某节点更方便（有 prev）
缺点：多一个指针，空间更大，操作更容易出错

（3）循环链表

尾节点指回头节点：

单循环：tail.next = head
双循环：tail.next = head 且 head.prev = tail

上述图片摘自：

C语言数据结构篇——循环链表的创建，插入，节点删除，打印等操作_如何显示循环链表的值,因为打印只能获取地址-ZEEKLOG博客

常用于需要“循环访问”的场景（例如约瑟夫环、轮询调度）。

第三部分：链表和数组的对比

对比点	数组（Array）	链表（Linked List）
存储	连续内存	非连续、节点分散
随机访问	快：O(1)	慢：O(n)
插入/删除（中间）	慢：移动元素 O(n)	快：改指针 O(1)*
扩容	可能要整体搬家	不需要扩容

设链表长度为 n：

查找第 k 个元素

必须从 head 开始一步步走：O(n)

头插（在 head 前插入）

直接改指针：O(1)

尾插

如果你没有 tail 指针：需要走到尾部 O(n)
如果维护 tail 指针：O(1)

删除某节点

已知该节点的前驱（单链表）或有 prev（双链表）：O(1)
不知道位置，需要先找：O(n)

第四部分：代码实现

（1）单链表

class Node: """链表节点类""" def __init__(self, data=None): self.data = data # 节点数据 self.next = None # 指向下一个节点的指针 class LinkedList: """单链表类""" def __init__(self): """初始化空链表""" self.head = None # 头节点 self.size = 0 # 链表长度 def is_empty(self): """检查链表是否为空""" return self.head is None def length(self): """返回链表长度""" return self.size def append(self, data): """在链表末尾添加节点""" new_node = Node(data) if self.is_empty(): self.head = new_node else: current = self.head while current.next: current = current.next current.next = new_node self.size += 1 def prepend(self, data): """在链表头部添加节点""" new_node = Node(data) new_node.next = self.head self.head = new_node self.size += 1 def insert(self, index, data): """在指定位置插入节点""" if index < 0 or index > self.size: raise IndexError("索引超出范围") if index == 0: self.prepend(data) elif index == self.size: self.append(data) else: new_node = Node(data) current = self.head for _ in range(index - 1): current = current.next new_node.next = current.next current.next = new_node self.size += 1 def delete(self, data): """删除第一个匹配的节点""" if self.is_empty(): return False # 如果要删除的是头节点 if self.head.data == data: self.head = self.head.next self.size -= 1 return True # 查找要删除的节点 current = self.head while current.next: if current.next.data == data: current.next = current.next.next self.size -= 1 return True current = current.next return False def delete_at(self, index): """删除指定位置的节点""" if index < 0 or index >= self.size: raise IndexError("索引超出范围") if index == 0: deleted_data = self.head.data self.head = self.head.next else: current = self.head for _ in range(index - 1): current = current.next deleted_data = current.next.data current.next = current.next.next self.size -= 1 return deleted_data def search(self, data): """查找节点是否存在""" current = self.head index = 0 while current: if current.data == data: return index current = current.next index += 1 return -1 def get(self, index): """获取指定位置的节点数据""" if index < 0 or index >= self.size: raise IndexError("索引超出范围") current = self.head for _ in range(index): current = current.next return current.data def update(self, index, data): """更新指定位置的节点数据""" if index < 0 or index >= self.size: raise IndexError("索引超出范围") current = self.head for _ in range(index): current = current.next current.data = data def reverse(self): """反转链表""" prev = None current = self.head while current: next_node = current.next current.next = prev prev = current current = next_node self.head = prev def to_list(self): """将链表转换为Python列表""" result = [] current = self.head while current: result.append(current.data) current = current.next return result def clear(self): """清空链表""" self.head = None self.size = 0 def __str__(self): """返回链表的字符串表示""" if self.is_empty(): return "空链表" nodes = [] current = self.head while current: nodes.append(str(current.data)) current = current.next return " -> ".join(nodes) + " -> None" def __len__(self): """支持len()函数""" return self.size def __getitem__(self, index): """支持索引访问""" return self.get(index) def __contains__(self, data): """支持in操作符""" return self.search(data) != -1 # 使用示例 if __name__ == "__main__": # 创建链表 linked_list = LinkedList() print("=== 单链表操作示例 ===") # 1. 添加元素 print("\n1. 添加元素:") linked_list.append(10) linked_list.append(20) linked_list.append(30) linked_list.prepend(5) linked_list.insert(2, 15) print(f"链表: {linked_list}") print(f"链表长度: {len(linked_list)}") print(f"链表转列表: {linked_list.to_list()}") # 2. 访问元素 print("\n2. 访问元素:") print(f"索引1的元素: {linked_list[1]}") print(f"获取索引2的元素: {linked_list.get(2)}") print(f"元素20的位置: {linked_list.search(20)}") print(f"元素100是否存在: {100 in linked_list}") # 3. 更新元素 print("\n3. 更新元素:") linked_list.update(2, 18) print(f"更新索引2后的链表: {linked_list}") # 4. 删除元素 print("\n4. 删除元素:") linked_list.delete(10) print(f"删除10后的链表: {linked_list}") deleted_data = linked_list.delete_at(1) print(f"删除索引1的元素: {deleted_data}") print(f"删除后的链表: {linked_list}") # 5. 反转链表 print("\n5. 反转链表:") linked_list.reverse() print(f"反转后的链表: {linked_list}") # 6. 其他操作 print("\n6. 其他操作:") print(f"链表是否为空: {linked_list.is_empty()}") print(f"链表长度: {linked_list.length()}") # 7. 清空链表 print("\n7. 清空链表:") linked_list.clear() print(f"清空后的链表: {linked_list}") print(f"链表是否为空: {linked_list.is_empty()}") # 扩展：带有尾指针的优化版本 class OptimizedLinkedList(LinkedList): """带尾指针的优化单链表""" def __init__(self): super().__init__() self.tail = None # 尾指针 def append(self, data): """优化版的append，时间复杂度O(1)""" new_node = Node(data) if self.is_empty(): self.head = new_node self.tail = new_node else: self.tail.next = new_node self.tail = new_node self.size += 1 def clear(self): """重写clear方法""" super().clear() self.tail = None # 测试优化版本 print("\n\n=== 带尾指针的优化链表 ===") opt_list = OptimizedLinkedList() opt_list.append(1) opt_list.append(2) opt_list.append(3) opt_list.append(4) print(f"优化链表: {opt_list}") print(f"头节点: {opt_list.head.data if opt_list.head else None}") print(f"尾节点: {opt_list.tail.data if opt_list.tail else None}")

基本功能：

创建和初始化链表
检查链表是否为空
获取链表长度

增操作：

append(): 在链表末尾添加
prepend(): 在链表头部添加
insert(): 在指定位置插入

删操作：

delete(): 删除指定值的节点
delete_at(): 删除指定位置的节点
clear(): 清空链表

查操作：

search(): 查找元素位置
get(): 获取指定位置的值
to_list(): 转换为Python列表

改操作：

update(): 更新指定位置的值

其他操作：

reverse(): 反转链表
__str__(): 友好的字符串表示
支持Python的len()、[]索引和in操作符

/data1/conda/zjc/env/MokA/bin/python /data1/zjc/MokA-main/VisualText/train/lihot.py
=== 单链表操作示例 ===

1. 添加元素:
链表: 5 -> 10 -> 15 -> 20 -> 30 -> None
链表长度: 5
链表转列表: [5, 10, 15, 20, 30]

2. 访问元素:
索引1的元素: 10
获取索引2的元素: 15
元素20的位置: 3
元素100是否存在: False

3. 更新元素:
更新索引2后的链表: 5 -> 10 -> 18 -> 20 -> 30 -> None

4. 删除元素:
删除10后的链表: 5 -> 18 -> 20 -> 30 -> None
删除索引1的元素: 18
删除后的链表: 5 -> 20 -> 30 -> None

5. 反转链表:
反转后的链表: 30 -> 20 -> 5 -> None

6. 其他操作:
链表是否为空: False
链表长度: 3

7. 清空链表:
清空后的链表: 空链表
链表是否为空: True

=== 带尾指针的优化链表 ===
优化链表: 1 -> 2 -> 3 -> 4 -> None
头节点: 1
尾节点: 4

进程已结束，退出代码为 0

（2）双向链表

class Node: """双向链表节点类""" def __init__(self, data=None): self.data = data # 节点数据 self.prev = None # 指向前一个节点的指针 self.next = None # 指向下一个节点的指针 class DoublyLinkedList: """双向链表类""" def __init__(self): """初始化空双向链表""" self.head = None # 头节点 self.tail = None # 尾节点 self.size = 0 # 链表长度 def __len__(self): """返回链表长度""" return self.size def is_empty(self): """检查链表是否为空""" return self.size == 0 def __str__(self): """返回链表的字符串表示""" if self.is_empty(): return "空链表" nodes = [] current = self.head while current: nodes.append(str(current.data)) current = current.next return " <-> ".join(nodes) def to_list(self): """将链表转换为Python列表""" result = [] current = self.head while current: result.append(current.data) current = current.next return result def to_list_reverse(self): """将链表反向转换为Python列表""" result = [] current = self.tail while current: result.append(current.data) current = current.prev return result def append(self, data): """在链表末尾添加节点""" new_node = Node(data) if self.is_empty(): # 链表为空时，新节点既是头节点也是尾节点 self.head = new_node self.tail = new_node else: # 链表不为空时，将新节点添加到尾部 new_node.prev = self.tail self.tail.next = new_node self.tail = new_node self.size += 1 return self def prepend(self, data): """在链表头部添加节点""" new_node = Node(data) if self.is_empty(): # 链表为空时，新节点既是头节点也是尾节点 self.head = new_node self.tail = new_node else: # 链表不为空时，将新节点添加到头部 new_node.next = self.head self.head.prev = new_node self.head = new_node self.size += 1 return self def insert(self, index, data): """在指定位置插入节点""" if index < 0 or index > self.size: raise IndexError(f"索引 {index} 超出范围 [0, {self.size}]") if index == 0: # 在头部插入 return self.prepend(data) elif index == self.size: # 在尾部插入 return self.append(data) else: # 在中间插入 new_node = Node(data) # 根据插入位置选择从头开始还是从尾开始遍历 if index < self.size // 2: # 从前半部分开始查找 current = self.head for _ in range(index): current = current.next else: # 从后半部分开始查找 current = self.tail for _ in range(self.size - index): current = current.prev # 插入新节点 new_node.prev = current.prev new_node.next = current current.prev.next = new_node current.prev = new_node self.size += 1 return self def delete(self, data): """删除第一个匹配的节点""" if self.is_empty(): return False current = self.head # 遍历查找要删除的节点 while current: if current.data == data: self._remove_node(current) return True current = current.next return False def delete_at(self, index): """删除指定位置的节点""" if index < 0 or index >= self.size: raise IndexError(f"索引 {index} 超出范围 [0, {self.size - 1}]") # 查找要删除的节点 if index < self.size // 2: current = self.head for _ in range(index): current = current.next else: current = self.tail for _ in range(self.size - index - 1): current = current.prev # 删除节点 data = current.data self._remove_node(current) return data def _remove_node(self, node): """内部方法：删除指定节点""" if node.prev: # 如果不是头节点 node.prev.next = node.next else: # 如果是头节点 self.head = node.next if node.next: # 如果不是尾节点 node.next.prev = node.prev else: # 如果是尾节点 self.tail = node.prev # 清理节点引用，帮助垃圾回收 node.prev = None node.next = None self.size -= 1 def search(self, data): """查找节点是否存在，返回索引列表（可能有重复值）""" indices = [] current = self.head index = 0 while current: if current.data == data: indices.append(index) current = current.next index += 1 return indices def get(self, index): """获取指定位置的节点数据""" if index < 0 or index >= self.size: raise IndexError(f"索引 {index} 超出范围 [0, {self.size - 1}]") # 根据位置选择从头开始还是从尾开始查找 if index < self.size // 2: current = self.head for _ in range(index): current = current.next else: current = self.tail for _ in range(self.size - index - 1): current = current.prev return current.data def update(self, index, data): """更新指定位置的节点数据""" if index < 0 or index >= self.size: raise IndexError(f"索引 {index} 超出范围 [0, {self.size - 1}]") # 查找要更新的节点 if index < self.size // 2: current = self.head for _ in range(index): current = current.next else: current = self.tail for _ in range(self.size - index - 1): current = current.prev current.data = data return self def reverse(self): """反转链表""" if self.size <= 1: return self current = self.head self.tail = self.head # 原来的头节点变成尾节点 while current: # 交换节点的prev和next指针 temp = current.prev current.prev = current.next current.next = temp # 移动到下一个节点（原来的prev节点） current = current.prev # 更新头节点 if self.tail: self.head = self.tail.prev return self def clear(self): """清空链表""" # 帮助垃圾回收：断开所有节点的引用 current = self.head while current: next_node = current.next current.prev = None current.next = None current = next_node self.head = None self.tail = None self.size = 0 return self def contains(self, data): """检查链表是否包含指定数据""" return len(self.search(data)) > 0 def __contains__(self, data): """支持in操作符""" return self.contains(data) def __getitem__(self, index): """支持索引访问""" return self.get(index) def __setitem__(self, index, value): """支持索引赋值""" self.update(index, value) def __iter__(self): """支持迭代""" current = self.head while current: yield current.data current = current.next def iter_reverse(self): """反向迭代器""" current = self.tail while current: yield current.data current = current.prev def pop_front(self): """删除并返回头节点数据""" if self.is_empty(): raise IndexError("链表为空") return self.delete_at(0) def pop_back(self): """删除并返回尾节点数据""" if self.is_empty(): raise IndexError("链表为空") return self.delete_at(self.size - 1) def front(self): """获取头节点数据""" if self.is_empty(): raise IndexError("链表为空") return self.head.data def back(self): """获取尾节点数据""" if self.is_empty(): raise IndexError("链表为空") return self.tail.data def remove_all(self, data): """删除所有匹配的节点""" if self.is_empty(): return 0 count = 0 current = self.head while current: next_node = current.next if current.data == data: self._remove_node(current) count += 1 current = next_node return count def copy(self): """创建链表的深拷贝""" new_list = DoublyLinkedList() current = self.head while current: new_list.append(current.data) current = current.next return new_list def extend(self, other_list): """将另一个链表连接到当前链表末尾""" if not isinstance(other_list, DoublyLinkedList): raise TypeError("只能连接DoublyLinkedList类型") if other_list.is_empty(): return self if self.is_empty(): self.head = other_list.head self.tail = other_list.tail else: self.tail.next = other_list.head other_list.head.prev = self.tail self.tail = other_list.tail self.size += other_list.size return self # 使用示例 if __name__ == "__main__": print("=== 双向链表操作示例 ===\n") # 1. 创建链表并添加元素 print("1. 创建链表并添加元素:") dll = DoublyLinkedList() dll.append(10).append(20).append(30) dll.prepend(5) dll.insert(2, 15) print(f"双向链表: {dll}") print(f"链表长度: {len(dll)}") print(f"转列表: {dll.to_list()}") print(f"反向转列表: {dll.to_list_reverse()}") # 2. 访问和遍历 print("\n2. 访问和遍历:") print(f"头节点: {dll.front()}") print(f"尾节点: {dll.back()}") print(f"索引2的元素: {dll[2]}") print(f"正向遍历: {[x for x in dll]}") print(f"反向遍历: {[x for x in dll.iter_reverse()]}") # 3. 搜索和检查 print("\n3. 搜索和检查:") print(f"元素15的位置: {dll.search(15)}") print(f"元素20是否存在: {20 in dll}") print(f"元素100是否存在: {100 in dll}") # 4. 更新元素 print("\n4. 更新元素:") dll[1] = 12 print(f"更新索引1后的链表: {dll}") # 5. 删除元素 print("\n5. 删除元素:") print(f"删除元素20: {dll.delete(20)}") print(f"删除后的链表: {dll}") print(f"删除索引1的元素: {dll.delete_at(1)}") print(f"删除后的链表: {dll}") print(f"删除头节点: {dll.pop_front()}") print(f"删除尾节点: {dll.pop_back()}") print(f"最终链表: {dll}") # 6. 反转链表 print("\n6. 反转链表:") dll.append(1).append(2).append(3).append(4) print(f"原始链表: {dll}") dll.reverse() print(f"反转后的链表: {dll}") # 7. 复制和扩展 print("\n7. 复制和扩展:") dll_copy = dll.copy() print(f"原始链表: {dll}") print(f"复制的链表: {dll_copy}") dll2 = DoublyLinkedList() dll2.append(100).append(200) dll.extend(dll2) print(f"扩展后的链表: {dll}") # 8. 删除所有匹配项 print("\n8. 删除所有匹配项:") dll.append(5).append(5).append(5) print(f"添加重复元素后: {dll}") removed_count = dll.remove_all(5) print(f"删除了 {removed_count} 个元素5") print(f"最终链表: {dll}") # 9. 清空链表 print("\n9. 清空链表:") dll.clear() print(f"清空后的链表: {dll}") print(f"链表是否为空: {dll.is_empty()}") # 扩展：带哨兵节点（头哨兵和尾哨兵）的双向链表 class DoublyLinkedListWithSentinel: """带哨兵节点的双向链表""" def __init__(self): """初始化带哨兵节点的双向链表""" self.head_sentinel = Node() # 头哨兵节点 self.tail_sentinel = Node() # 尾哨兵节点 # 连接头尾哨兵 self.head_sentinel.next = self.tail_sentinel self.tail_sentinel.prev = self.head_sentinel self.size = 0 def __len__(self): return self.size def is_empty(self): return self.size == 0 def __str__(self): if self.is_empty(): return "空链表" nodes = [] current = self.head_sentinel.next while current != self.tail_sentinel: nodes.append(str(current.data)) current = current.next return " <-> ".join(nodes) def _insert_between(self, data, predecessor, successor): """在predecessor和successor之间插入节点""" new_node = Node(data) new_node.prev = predecessor new_node.next = successor predecessor.next = new_node successor.prev = new_node self.size += 1 return new_node def _remove_node(self, node): """删除指定节点""" predecessor = node.prev successor = node.next predecessor.next = successor successor.prev = predecessor # 清理引用 node.prev = None node.next = None self.size -= 1 return node.data def append(self, data): """在链表末尾添加节点""" self._insert_between(data, self.tail_sentinel.prev, self.tail_sentinel) return self def prepend(self, data): """在链表头部添加节点""" self._insert_between(data, self.head_sentinel, self.head_sentinel.next) return self def insert(self, index, data): """在指定位置插入节点""" if index < 0 or index > self.size: raise IndexError(f"索引 {index} 超出范围") if index == 0: return self.prepend(data) elif index == self.size: return self.append(data) # 找到插入位置的前驱节点 if index < self.size // 2: current = self.head_sentinel.next for _ in range(index - 1): current = current.next else: current = self.tail_sentinel.prev for _ in range(self.size - index): current = current.prev self._insert_between(data, current, current.next) return self def delete_at(self, index): """删除指定位置的节点""" if index < 0 or index >= self.size: raise IndexError(f"索引 {index} 超出范围") # 找到要删除的节点 if index < self.size // 2: current = self.head_sentinel.next for _ in range(index): current = current.next else: current = self.tail_sentinel.prev for _ in range(self.size - index - 1): current = current.prev return self._remove_node(current) # 测试带哨兵节点的版本 print("\n\n=== 带哨兵节点的双向链表 ===") sentinel_dll = DoublyLinkedListWithSentinel() sentinel_dll.append(10).append(20).append(30).prepend(5) print(f"带哨兵的链表: {sentinel_dll}") print(f"链表长度: {len(sentinel_dll)}") sentinel_dll.insert(2, 15) print(f"在索引2插入15后: {sentinel_dll}") print(f"删除索引1的元素: {sentinel_dll.delete_at(1)}") print(f"删除后: {sentinel_dll}")

基本特性：

每个节点包含前驱指针(prev)和后继指针(next)
维护头节点(head)和尾节点(tail)引用
支持双向遍历

增操作：

append(): 在链表末尾添加
prepend(): 在链表头部添加
insert(): 在指定位置插入

删操作：

delete(): 删除第一个匹配的节点
delete_at(): 删除指定位置的节点
pop_front(): 删除并返回头节点
pop_back(): 删除并返回尾节点
remove_all(): 删除所有匹配的节点
clear(): 清空链表

查操作：

get() / []: 获取指定位置的值
search(): 查找元素位置
contains() / in: 检查元素是否存在
front(): 获取头节点数据
back(): 获取尾节点数据

遍历操作：

__iter__(): 正向迭代
iter_reverse(): 反向迭代
to_list(): 转换为列表
to_list_reverse(): 反向转换为列表

其他操作：

update() / [] =: 更新指定位置的值
reverse(): 反转链表
copy(): 深拷贝链表
extend(): 连接另一个链表

扩展功能：
我还提供了一个带哨兵节点的优化版本，可以简化边界条件的处理，避免对头尾节点的特殊判断。

双向链表的优势：

可以从两个方向遍历链表
删除节点时不需要知道前驱节点
在某些操作上比单链表更高效
支持反向迭代

/data1/conda/zjc/env/MokA/bin/python /data1/zjc/MokA-main/VisualText/train/lihot.py
=== 双向链表操作示例 ===

1. 创建链表并添加元素:
双向链表: 5 <-> 15 <-> 10 <-> 20 <-> 30
链表长度: 5
转列表: [5, 15, 10, 20, 30]
反向转列表: [30, 20, 10, 15, 5]

2. 访问和遍历:
头节点: 5
尾节点: 30
索引2的元素: 10
正向遍历: [5, 15, 10, 20, 30]
反向遍历: [30, 20, 10, 15, 5]

3. 搜索和检查:
元素15的位置: [1]
元素20是否存在: True
元素100是否存在: False

4. 更新元素:
更新索引1后的链表: 5 <-> 12 <-> 10 <-> 20 <-> 30

5. 删除元素:
删除元素20: True
删除后的链表: 5 <-> 12 <-> 10 <-> 30
删除索引1的元素: 12
删除后的链表: 5 <-> 10 <-> 30
删除头节点: 5
删除尾节点: 30
最终链表: 10

6. 反转链表:
原始链表: 10 <-> 1 <-> 2 <-> 3 <-> 4
反转后的链表: 1 <-> 10

7. 复制和扩展:
原始链表: 1 <-> 10
复制的链表: 1 <-> 10
扩展后的链表: 1 <-> 10 <-> 100 <-> 200

8. 删除所有匹配项:
添加重复元素后: 1 <-> 10 <-> 100 <-> 200 <-> 5 <-> 5 <-> 5
删除了 3 个元素5
最终链表: 1 <-> 10 <-> 100 <-> 200

9. 清空链表:
清空后的链表: 空链表
链表是否为空: True

=== 带哨兵节点的双向链表 ===
带哨兵的链表: 5 <-> 10 <-> 20 <-> 30
链表长度: 4
在索引2插入15后: 5 <-> 10 <-> 15 <-> 20 <-> 30
删除索引1的元素: 10
删除后: 5 <-> 15 <-> 20 <-> 30

进程已结束，退出代码为 0

（3）构造一个简易的单链表

# 构造链表A: 1 → 2 → 3 → 4 → 5 # 方式1：分步创建每个节点，直观易懂（推荐新手） node1 = ListNode(1) # 第一个节点（值为1） node2 = ListNode(2) # 第二个节点（值为2） node3 = ListNode(3) # 第三个节点（值为3） node4 = ListNode(4) # 第四个节点（值为4） node5 = ListNode(5) # 第五个节点（值为5） # 建立节点间的指向关系 node1.next = node2 # 1 → 2 node2.next = node3 # 2 → 3 node3.next = node4 # 3 → 4 node4.next = node5 # 4 → 5 # node5.next 默认为 None，无需额外赋值（链表尾节点） # 链表A的头节点是node1 headA = node1 # 验证：遍历链表输出节点值，确认构造正确 def print_linked_list(head): current = head while current: print(current.val, end=" → ") current = current.next print("None") # 标记链表结束 # 调用验证函数 print("构造的链表A：") print_linked_list(headA)