【数据结构专项】链表(2) —— 链表的基本操作(Python)

单链表的基本操作（包含头结点的单链表）

# 单链表结点类
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