【数据结构基础_链表】

1、链表的定义

链表与数组的区分：

数组是一块连续的内存空间，有了这块内存空间的首地址，就能直接通过索引计算出任意位置的元素地址。 数组最大的优势是支持通过索引快速访问元素，而链表就不支持。 链表不一样，一条链表并不需要一整块连续的内存空间存储元素。 链表的元素可以分散在内存空间的天涯海角，通过每个节点上的 next, prev 指针，将零散的内存块串联起来形成一个链式结构。 1）这样可以提高内存的利用效率，链表的节点不需要挨在一起，给点内存 new 出来一个节点就能用，操作系统会觉得这娃好养活 2）另外一个好处，它的节点要用的时候就能接上，不用的时候拆掉就行了，从来不需要考虑扩缩容和数据搬移的问题 弊端： 因为元素并不是紧挨着的，所以如果你想要访问第 3 个链表元素，你就只能从头结点开始往顺着 next 指针往后找，直到找到第 3 个节点才行。 二、链表的类型 1、单链表

编程语言标准库一般都会提供泛型，即你可以指定 val 字段为任意类型，而力扣的单链表节点的 val 字段只有 int 类型。

class ListNode: def __init__(self, x): self.val = x self.next = None 2、双链表

编程语言标准库一般使用的都是双链表而非单链表。

单链表节点只有一个 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.next 2、增

在头部增加新节点

# 创建一条单链表 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 -> 5 3、删

删除一个节点，首先要找到要被删除节点的前驱节点，然后把这个前驱节点的 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 为true  1、查

对于双链表的遍历和查找，我们可以从头节点或尾节点开始，根据需要向前或向后遍历：

# 创建一条双链表 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.prev 2、增

在链表头节点插入一个值

# 创建一条双链表 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，就可以