單鏈表的基本操作（包含頭結點的單鏈表）
# 單鏈表結點類
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