链表理论
文章链接：代码随想录
1. 链表定义
链表是一种通过指针串联的灵活线性数据结构，内存地址不连续。链表的各个节点可以被分散在内存的各个地方。
链表的每个节点由一个数据域和一个指针域组成。指针域存放指向下一个节点的指针，如果是最后一个节点，则其指针域指向NULL（空指针）。链表的入口节点称为链表的头结点（head）
2.链表的类型
2.1 单链表
来自代码随想录网站上的图片，很好的解释了什么是单向链表。
-
特点：每个节点的指针域指向下一个节点，且仅只有一个节点。
2.2 双链表
每个节点包含两个指针域，一个指向下一个节点，一个指向上一个节点。因此，双链表即可向前查询也可向后查询
2.3 循环链表
链表首尾相连，但是每个节点只有一个指针域。和单向链表唯一不同的是循环链表的最后一个节点指针域指向head。
循环链表可以用来解决约瑟夫环问题。
3. 链表的书写
class ListNode: def __init__(self, val, next=None): self.val = val # 节点值 self.next = next # 指向下一个节点的引用
4. 链表的操作
4.1 删除节点
只需要将删除的上一个节点指向删除的下一个节点即可
即如下如所示：
4.2 添加节点
将要添加位置的指针指向被添加的数据域，这个数据域的指针指向下一个节点。即如下图所示：
链表的增添和删除都是O(1)操作，也不会影响到其他节点。
要是删除第五个节点，需要从头节点查找到第四个节点通过next指针进行删除操作，查找的时间复杂度是O(n)。
5. 与数组对比
| 数组 | 链表 | |
|---|---|---|
| 插入/删除（时间复杂度） | O(n) | O(1) |
| 查询（时间复杂度） | O(1) | O(n) |
| 适用场景 | 数据量固定，频繁查找，较少增删 | 数据量不固定，频繁增删，较少查询 |
| 其他 | 如果改动长度，需要重新定义一个新数组 | 具有动态增删的特点 |
203.移除链表元素
题目链接：力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台
文章讲解：代码随想录
视频讲解：手把手带你学会操作链表 | LeetCode：203.移除链表元素_哔哩哔哩_bilibili
关键需要理解虚拟头结点的使用技巧。
题目：
给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。
示例 1：
输入：head = [1,2,6,3,4,5,6], val = 6 输出：[1,2,3,4,5]
示例 2：
输入：head = [], val = 1 输出：[]
示例 3：
输入：head = [7,7,7,7], val = 7 输出：[]
思路：
链表的删除操作还是比较简单的。但是在删除的过程中需要注意：当前删除的是否是头节点，如果是的话就要麻烦一些了。因为头节点没有前置节点。所以一般有两种链表删除方式：
-
直接使用原来的链表进行删除操作（直接删除，需要考虑是否为头节点的情况）
-
设置一个虚拟头节点进行删除操作
算法：虚拟头节点
题解：
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, val=0, next=None):
# self.val = val
# self.next = next
class Solution:
def removeElements(self, head: Optional[ListNode], val: int) -> Optional[ListNode]:
# 构造一个虚拟的头节点
dummy_head = ListNode(next=head)
# 遍历列表并删除值为val的节点
# 当前的指针停留在虚拟头节点上
current = dummy_head
while current.next:
if current.next.val == val:
current.next = current.next.next # 如果虚拟头节点指向的下一个值和val相等，即current.next.val = val，那么就让current.next指向current的下下个节点。因为当前current.next已经被删除了。
else:
current = current.next #如果当前的下一个不是删除节点，那么就将current继续往下一个移动
return dummy_head.next # 虚拟头节点的下一个即为新的头节点
707.设计链表
题目链接：力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台
文章讲解：代码随想录
题目：
你可以选择使用单链表或者双链表，设计并实现自己的链表。
单链表中的节点应该具备两个属性：val 和 next 。val 是当前节点的值，next 是指向下一个节点的指针/引用。
如果是双向链表，则还需要属性 prev 以指示链表中的上一个节点。假设链表中的所有节点下标从 0 开始。
实现 MyLinkedList 类：
-
MyLinkedList()初始化MyLinkedList对象。 -
int get(int index)获取链表中下标为index的节点的值。如果下标无效，则返回-1。 -
void addAtHead(int val)将一个值为val的节点插入到链表中第一个元素之前。在插入完成后，新节点会成为链表的第一个节点。 -
void addAtTail(int val)将一个值为val的节点追加到链表中作为链表的最后一个元素。 -
void addAtIndex(int index, int val)将一个值为val的节点插入到链表中下标为index的节点之前。如果index等于链表的长度，那么该节点会被追加到链表的末尾。如果index比长度更大，该节点将 不会插入 到链表中。 -
void deleteAtIndex(int index)如果下标有效，则删除链表中下标为index的节点。
思路：
主要需要完成如下的任务：
-
获取链表第n个节点的数值：设置n遍历链表的长度范围（大于0，小于链表的长度）超过范围返回-1。定义一个新节点，for循环遍历index，如果指到第n个，则返回其对应值。
-
在链表的头部插入一个节点: 定义一个新节点，先让新节点指向头结点，然后再让虚拟节点指向新节点
-
在链表的尾部插入一个节点：找到尾部节点的特点（指向空指针），如果尾部不指向空指针，则current指针指向current.next，此时按上一个步骤插入即可，让current.next->newcode
-
在链表第n个节点前面插入一个节点：结合第一题，然后插入节点
-
删除链表的第n个节点：这一题也要注意设置n的遍历范围（大于0，小于链表的长度）。定义一个虚拟头结点，当删除后，current就指向next的next。当删除之后，链表的长度减1。
可以试着使用虚拟头节点的方式来进行求解。
题解：
class ListNode:
def __init__(self, val = 0, next = None):
self.val = val
self.next = next
class MyLinkedList:
def __init__(self):
self.dummy_head = ListNode()
self.size = 0
def get(self, index: int) -> int:
if index < 0 or index >= self.size:
return -1
current = self.dummy_head.next
for i in range(index):
current = current.next
return current.val
def addAtHead(self, val: int) -> None:
self.dummy_head.next = ListNode(val, self.dummy_head.next) # ListNode(val, self.dummy_head.next) 使用虚拟头结点的方式，将需要加入链表的元素先加入到链表中，然后再将整体链表的虚拟头结点指向新加入的节点。
self.size += 1
def addAtTail(self, val: int) -> None:
current = self.dummy_head
while current.next:
current = current.next
current.next = ListNode(val) # 直接加入尾部，将虚拟头结点指向这个链表的值。
self.size += 1
def addAtIndex(self, index: int, val: int) -> None:
if index < 0 or index > self.size: # 考虑极端情况，如果等于链表长度，就可能是在尾结点之后插入了
return
current = self.dummy_head
for i in range(index):
current = current.next
current.next = ListNode(val, current.next)
self.size += 1
def deleteAtIndex(self, index: int) -> None:
if index < 0 or index >= self.size:
return
current = self.dummy_head
for i in range(index):
current = current.next
current.next = current.next.next
self.size -= 1
# Your MyLinkedList object will be instantiated and called as such:
# obj = MyLinkedList()
# param_1 = obj.get(index)
# obj.addAtHead(val)
# obj.addAtTail(val)
# obj.addAtIndex(index,val)
# obj.deleteAtIndex(index)206.反转链表（常考）
题目链接：力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台
文章讲解：代码随想录
视频讲解：帮你拿下反转链表 | LeetCode：206.反转链表 | 双指针法 | 递归法_哔哩哔哩_bilibili
题目：
给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。
示例 1：
输入：head = [1,2,3,4,5] 输出：[5,4,3,2,1]
思路：
可以使用两种解题的方法：双指针法和递归的方法
递归解法由双指针解法而来。
算法：
-
双指针法：
-
定义两个指针，current=head, pre =Null(指向head前面的空位置)，互相指
-
注意，要再定义一个指针来保存current的下一个位置。避免丢失
-
当current指向了空指针，则暂停遍历，返回pre节点的位置。即新链表的头结点为pre指针
-
-
递归法：编写一个函数进行调用。需要想清楚这个函数需要赋予什么参数。reverse(current, pre)
题解：
-
解法一：双指针法
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, val=0, next=None):
# self.val = val
# self.next = next
class Solution:
def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
current = head
pre_current = None
while current:
temp = current.next # 保存current指针的下一个节点位置，因为接下来需要逆转链表方向
current.next = pre_current # 翻转 当current指向其前一个位置（即pre_current的位置）时，代表此时current的指向位置已经翻转了。
#更新pre/current的位置
pre_current = current # 先让pre指针移动到当前current的位置，保证pre能够在当前的链表中继续向后遍历，直至遍历完整个链表。
current = temp # 此时，current移动到此前保存的位置，继续翻转
return pre_current-
解法二：递归法
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, val=0, next=None):
# self.val = val
# self.next = next
class Solution:
def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
return self.reverse(head, None)
def reverse(self, current: ListNode, pre_current: ListNode) -> ListNode:
# 设置链表遍历的停止条件：即当current指针指向了Null时，停止遍历，此时pre指针刚好指向尾结点
if current == None:
return pre_current
# 记录一下current的下一个位置
temp = current.next
current.next = pre_current # 移动pre指针
# 使用reverse来进行翻转(根据双指针的方法，此时pre_current指针移动到current的位置，current移动到下一个暂存的位置。始终要保证pre在current前，先移动pre_current)
return self.reverse(temp, current)
扫一扫
378
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
