【数据结构基础_链表】
1、链表的定义
链表与数组的区分：
数组是一块连续的内存空间，有了这块内存空间的首地址，就能直接通过索引计算出任意位置的元素地址。
数组最大的优势是支持通过索引快速访问元素，而链表就不支持。
链表不一样，一条链表并不需要一整块连续的内存空间存储元素。
链表的元素可以分散在内存空间的天涯海角，通过每个节点上的 next, prev 指针，将零散的内存块串联起来形成一个链式结构。
1）这样可以提高内存的利用效率，链表的节点不需要挨在一起，给点内存 new 出来一个节点就能用，操作系统会觉得这娃好养活
2）另外一个好处，它的节点要用的时候就能接上，不用的时候拆掉就行了，从来不需要考虑扩缩容和数据搬移的问题
弊端：
因为元素并不是紧挨着的，所以如果你想要访问第 3 个链表元素，你就只能从头结点开始往顺着 next 指针往后找，直到找到第 3 个节点才行。二、链表的类型
1、单链表
编程语言标准库一般都会提供泛型，即你可以指定 val 字段为任意类型，而力扣的单链表节点的 val 字段只有 int 类型。
class ListNode:
def __init__(self, x):
self.val = x
self.next = None2、双链表
编程语言标准库一般使用的都是双链表而非单链表。
单链表节点只有一个 next 指针，指向下一个节点；
而双链表节点有两个指针，prev 指向前一个节点，next 指向下一个节点。
class Node:
def __init__(self, prev, element, next):
self.val = element
self.next = next #指向下个元素的指针
self.prev = prev #指向上个元素的指针三、单链表的操作
首先，要创建一个单链表，来用于下面的操作
class ListNode:
def __init__(self, x): # 修正了 __int__ 为 __init__
self.val = x
self.next = None
def createlinkedlist(arry: 'List[int]') -> ListNode:
if arry is None or len(arry) == 0:
return None
head = ListNode(arry[0]) # 创建头节点
current = head # 使用一个指针来遍历链表
for i in range(1, len(arry)):
current.next = ListNode(arry[i]) # 创建新节点并链接
current = current.next # 移动指针
return head # 返回链表的头节点1、对节点进行赋值，必须转化为ListNode类型
head = ListNode(arry[0]) # 创建头节点
current.next = ListNode(arry[i]) # 创建新节点并链接
错误写法：current.next = arry[i]
2、必须使用指针来遍历链表
head = ListNode(arry[0]) # 创建头节点
current = head # 使用一个指针来遍历链表
问题：为什么需要使用指针（如 current）？
1、保持链表头节点的引用
链表的头节点是链表的入口点，通常需要保持对它的引用，以便后续可以访问整个链表。如果不使用额外的指针，直接操作 head，可能会导致以下问题：
1）丢失链表头节点：在链表操作过程中，如果直接修改 head，可能会意外地丢失对链表的引用，导致无法再访问链表的其他部分。
2)无法返回链表头节点：在函数中创建链表时，最终需要返回链表的头节点。如果不使用额外的指针，直接操作 head，可能会导致返回的头节点指向错误的位置。
2、方便链表的遍历和操作
使用指针（如 current）可以方便地遍历链表，并在遍历过程中对链表进行操作（如插入、删除节点）。指针的作用类似于一个“游标”，可以在不改变链表头节点的情况下，逐个访问链表的节点。
3、如果不使用指针：
def createlinkedlist(arry: 'List[int]') -> ListNode:
。。。
head = ListNode(arry[0])
for i in range(1, len(arry)):
head.next = ListNode(arry[i])
head = head.next # 直接修改 head
return head # 返回的是最后一个节点，而不是头节点运行结果：
1、查
# 创建一条单链表
head = createLinkedList([1, 2, 3, 4, 5])
# P为指针，遍历单链表
p = head
while p is not None:
print(p.val)
p = p.next2、增
在头部增加新节点
# 创建一条单链表
head = createLinkedList([1, 2, 3, 4, 5])
# 在单链表头部插入一个新节点 0
newHead = ListNode(0)
newHead.next = head
head = newHead
# 现在链表变成了 0 -> 1 -> 2 -> 3 -> 4 -> 5在尾部增加新节点
# 创建一条单链表
head = createLinkedList([1, 2, 3, 4, 5])
# 在单链表尾部插入一个新节点 6
p = head
# 先走到链表的最后一个节点
while p.next is not None:
p = p.next
# 现在 p 就是链表的最后一个节点
# 在 p 后面插入新节点
p.next = ListNode(6)
# 现在链表变成了 1 -> 2 -> 3 -> 4 -> 5 -> 6在单链表中间插入新元素
# 创建一条单链表
head = createLinkedList([1, 2, 3, 4, 5])
# 在第 3 个节点后面插入一个新节点 66
# 先要找到前驱节点，即第 3 个节点
p = head
for _ in range(2):
p = p.next
# 此时 p 指向第 3 个节点
# 组装新节点的后驱指针
new_node = ListNode(66)
new_node.next = p.next
# 插入新节点
p.next = new_node
# 现在链表变成了 1 -> 2 -> 3 -> 66 -> 4 -> 53、删
删除一个节点，首先要找到要被删除节点的前驱节点，然后把这个前驱节点的 next 指针指向被删除节点的下一个节点。这样就能把被删除节点从链表中摘除了。
# 创建一条单链表
head = createLinkedList([1, 2, 3, 4, 5])
# 删除第 4 个节点，要操作前驱节点
p = head
for i in range(2):
p = p.next
# 此时 p 指向第 3 个节点，即要删除节点的前驱节点
# 把第 4 个节点从链表中摘除
p.next = p.next.next
# 现在链表变成了 1 -> 2 -> 3 -> 5在单链表尾部删除元素
# 创建一条单链表
head = createLinkedList([1, 2, 3, 4, 5])
# 删除尾节点
p = head
# 找到倒数第二个节点
while p.next.next is not None:
p = p.next
# 此时 p 指向倒数第二个节点
# 把尾节点从链表中摘除
p.next = None
# 现在链表变成了 1 -> 2 -> 3 -> 4在单链表头部删除元素
# 创建一条单链表
head = createLinkedList([1, 2, 3, 4, 5])
# 删除头结点
head = head.next
# 现在链表变成了 2 -> 3 -> 4 -> 5四、双链表的操作
class DoublyListNode:
def __init__(self, x):
self.val = x
self.next = None
self.prev = None
def createDoublyLinkedList(arr: List[int]) -> Optional[DoublyListNode]:
if not arr:
return None
head = DoublyListNode(arr[0])
cur = head
# for 循环迭代创建双链表
for val in arr[1:]:#基于切片进行迭代
new_node = DoublyListNode(val)
cur.next = new_node
new_node.prev = cur
cur = cur.next
return head判断空列表：
方式一：更加显式
if arr is None or len(arr):
方式二：更加简洁
if not arr:
在 Python 中，if not arr 是一种简洁的写法，用于检查一个可迭代对象（如列表、字符串、字典等）是否为空。它基于 Python 的布尔上下文（Boolean Context）：
如果 arr 是 None 或者是一个空列表（[]），if not arr 的条件为 True。
如果 arr 是一个非空列表（如 [1, 2, 3]），if not arr 的条件为 False。
因此，if not arr 可以同时检查 arr 是否为 None 或者是否为空列表。
0为false,非0 为true1、查
对于双链表的遍历和查找，我们可以从头节点或尾节点开始，根据需要向前或向后遍历：
# 创建一条双链表
head = createDoublyLinkedList([1, 2, 3, 4, 5])
tail = None
# 1、从头节点向后遍历双链表
p = head
while p:
print(p.val)
tail = p
p = p.next
# 2、从尾节点向前遍历双链表
p = tail
while p:
print(p.val)
p = p.prev2、增
在链表头节点插入一个值
# 创建一条双链表
head = create_doubly_linked_list([1, 2, 3, 4, 5])
# 在双链表头部插入新节点 0
new_head = DoublyListNode(0)
new_head.next = head
head.prev = new_head
head = new_head
# 现在链表变成了 0 -> 1 -> 2 -> 3 -> 4 -> 5在链表尾部插入一个值
# 创建一条双链表
head = createDoublyLinkedList([1, 2, 3, 4, 5])
# p是一个指针，初始化是从头节点开始
p = head
# 先走到链表的最后一个节点
while p.next is not None:
p = p.next
# 在双链表尾部插入新节点 6
newNode = DoublyListNode(6)
p.next = newNode
newNode.prev = p
# 更新尾节点引用
p = newNode
# 现在链表变成了 1 -> 2 -> 3 -> 4 -> 5 -> 6在双链表中间插入元素
# 创建一条双链表
head = createDoublyLinkedList([1, 2, 3, 4, 5])
# 在第 3 个节点后面插入新节点 66
# 找到第 3 个节点
p = head
for _ in range(2): #range(2)代表0,1
p = p.next
# 组装新节点
newNode = DoublyListNode(66)
newNode.next = p.next
newNode.prev = p
# 插入新节点
p.next.prev = newNode
p.next = newNode
# 现在链表变成了 1 -> 2 -> 3 -> 66 -> 4 -> 5解释
_ 是一个特殊的变量名，通常被称为“占位符变量”
for _ in range(2): 的作用
for _ in range(2): 的意思是：循环两次，每次循环中 _ 的值会从 range(2) 中依次取值（即 0 和 1），但 _ 的值在循环体中不会被使用。3、删
在双链表中删除一个节点，需要调整前驱节点和后继节点的指针
# 创建一条双链表
head = createDoublyLinkedList([1, 2, 3, 4, 5])
# 删除第 4 个节点
# 先找到第 3 个节点
p = head
for i in range(2):
p = p.next
# 现在 p 指向第 3 个节点，我们将它后面的那个节点摘除出去
toDelete = p.next
# 把 toDelete 从链表中摘除
p.next = toDelete.next
toDelete.next.prev = p
# 把 toDelete 的前后指针都置为 null 是个好习惯（可选）
toDelete.next = None
toDelete.prev = None
# 现在链表变成了 1 -> 2 -> 3 -> 5在双链表头部删除元素
# 创建一条双链表
head = createDoublyLinkedList([1, 2, 3, 4, 5])
# 删除头结点
toDelete = head
head = head.next
head.prev = None
# 清理已删除节点的指针
toDelete.next = None
# 现在链表变成了 2 -> 3 -> 4 -> 5在双链表尾部删除元素
# 创建一条双链表
head = createDoublyLinkedList([1, 2, 3, 4, 5])
# 删除尾节点
p = head
# 找到尾结点
while p.next is not None:
p = p.next
# 现在 p 指向尾节点
# 把尾节点从链表中摘除
p.prev.next = None
# 把被删结点的指针都断开是个好习惯（可选）
p.prev = None
# 现在链表变成了 1 -> 2 -> 3 -> 4防止内存泄漏：把删除的元素，赋值为None，就可以