单链表的基本操作（包含头结点的单链表）
# 单链表结点类
class ListNode:
def __init__(self, val):
self.val = val
self.next = None
def __str__(self):
return str(self.val) + "->" + str(self.next)
单链表的读取(给定读取坐标)：读取第index个结点的值。（时间复杂度：O(n)）
# 单链表的读取(给定读取坐标)
def get_node_by_index(head: "ListNode", index: int):
for _ in range(index + 1): # 寻找第index个结点(从0开始计数)的前一个结点，如果链表长度不足则不删除
if not head.next:
return None
head = head.next
else:
return head.val
单链表的添加操作(在给定结点后添加)：在给定的结点prev后，添加新值value。（时间复杂度：O(1)）
# 单链表的添加操作（在给定结点后添加）
def add_node_by_prev(prev: "ListNode", value):
node = ListNode(value) # 使用给定值初始化新结点(node)
node.next = prev.next # 令新结点(node)指向给定结点(prev)的下一个结点
prev.next = node # 令给定结点(prev)指向新结点(node)
单链表的添加操作(给定插入坐标)：在第index个（不包括头结点，从0开始计数）结点后，添加新值value。（时间复杂度：O(n)）
# 单链表的添加操作(给定插入坐标)
def add_node_by_index(head: "ListNode", index: int, value):
idx = -1 # 因为从头结点开始遍历，故使用头结点的坐标-1
while idx < index and head.next: # 寻找第index个结点(从0开始计数)，如果链表长度不足则添加在链表尾部
head = head.next
idx += 1
add_value_by_node(head, value) # 在第index个结点后添加新结点
单链表的删除操作(在给定结点后删除)：删除给定结点prev的下一个结点。（时间复杂度：O(1)）
# 单链表的删除操作（在给定结点后删除）
def delete_node_by_prev(prev: "ListNode"):
prev.next = prev.next.next # 令给定结点(prev)直接指向被删除结点的下一个结点
单链表的删除操作(给定删除坐标)：删除第index个结点（不包括头结点，从0开始计数）。（时间复杂度：O(n)）
# 单链表的删除操作(给定删除坐标)
def delete_node_by_index(head: "ListNode", index: int):
for _ in range(index): # 寻找第index个结点(从0开始计数)的前一个结点，如果链表长度不足则不删除
if not head.next:
break
head = head.next
else:
delete_node_by_prev(head)
单链表的整表创建(包含头结点)：类似于数组的初始化，即声明一个类型和大小的数组并赋值的过程。（时间复杂度：O(n)）
# 单链表的整表创建
def build_singly_list_node(values: List):
node = head = ListNode(None) # 创建头结点，node指向尾结点（此时即头结点）
for value in values:
node.next = ListNode(value) # 创建新结点，并令当前链表尾部的终端结点指向新结点
node = node.next # node重新指向尾结点（即新创建的节点）
return head
单链表基本操作的测试：
if __name__ == "__main__":
head = build_singly_list_node([1, 2, 3, 4, 5])
print(head) # None->1->2->3->4->5->None
add_node_by_prev(head.next, 6)
print(head) # None->1->6->2->3->4->5->None
add_node_by_index(head, 3, 10)
print(head) # None->1->6->2->3->10->4->5->None
delete_node_by_prev(head.next)
print(head) # None->1->2->3->10->4->5->None
delete_node_by_index(head, 2)
print(head) # None->1->2->10->4->5->None
print(get_node_by_index(head, 3)) # 4
双链表的基本操作
from simply_linked_list import ListNode
# 双链表结点类
class DoublyListNode(ListNode):
def __init__(self, val):
super().__init__(val)
self.prev = None
def __str__(self):
if self.next and self.next.val:
return str(self.val) + "<->" + str(self.next)
else:
return str(self.val) + "<->" + "None"
双链表的添加操作(在给定结点后添加)：在给定的结点prev后，添加新值value。（时间复杂度：O(1)）
# 双链表的添加操作(在给定结点后添加)
def add_node_by_prev(prev: "DoublyListNode", value):
node = DoublyListNode(value) # 使用给定值初始化新结点(node)
node.prev = prev # 令新结点(node)的前驱指针指向给定结点(prev)
node.next = prev.next # 令新结点(node)的后续指针指向给定结点(prev)的后一个结点
prev.next = node # 令给定结点(prev)的后驱指针指向新结点
node.next.prev = node # 令后一个节点的前驱指针指向新结点
双链表的删除操作(删除给定结点)：删除给定的节点node。（时间复杂度：O(1)）
# 双链表的删除操作(删除给定结点)
def delete_node_by_node(node: "DoublyListNode"):
node.prev.next, node.next.prev = node.next, node.prev # 令给定结点前一个结点的后驱指针指向给定结点的后驱结点，后一个结点的前驱指针指向给定结点的前驱结点
双链表的整表创建(包含头结点)：类似于数组的初始化，即声明一个类型和大小的数组并赋值的过程。（时间复杂度：O(n)）
# 双链表的整表创建
def build_doubly_list_node(values: List):
node = head = DoublyListNode(None) # 创建头结点，node指向尾结点（此时即头结点）
for value in values:
new = DoublyListNode(value) # 创建新结点
new.prev = node # 令新结点的前驱指针指向当前节点
new.next = head # 令新结点的后继指针指向当前节点
node.next = new # 并令当前链表尾部的终端结点指向新结点
node = node.next # node重新指向尾结点（即新创建的节点）
head.prev = node # 令头结点的前驱指针指向链表尾部的终端结点
return head
双链表基本操作的测试：
if __name__ == "__main__":
head = build_doubly_list_node([1, 2, 3, 4, 5])
print(head) # None<->1<->2<->3<->4<->5<->None
add_node_by_prev(head.next.next, 10)
print(head) # None<->1<->2<->10<->3<->4<->5<->None
delete_node_by_node(head.next.next.next)
print(head) # None<->1<->2<->3<->4<->5<->None
