目录
链表理论基础
链表的类型
单链表
单链表是一种通过指针串联在一起的线性结构,每一个节点由两部分组成,一个是数据域一个是指针域(存放指向下一个节点的指针),最后一个节点的指针域指向null。
指针的入口节点称为链表的头节点,head。
双链表
双链表的每个节点有两个指针域,一个指向下一个节点,一个指向上一个节点,也就是既可以向前查询也可以向后查询。
循环链表
循环链表就是链表首尾相连,可以用来解决约瑟夫环问题。
链表的存储方式
数组在内存中是连续分布的,但是链表在内存中不是连续分布的。
链表是通过指针域的指针链接内存中各个节点。
如下图中的链表,起始节点为2,终止节点为7,各个节点分布在不同地址空间上,通过指针串联在一起。
链表的定义
class ListNode:
def __init__(self, val, next=None):
self.val = val
self.next = next
链表的操作
删除节点
删除节点时只需将前一个节点的next指针指向下一个节点即可,python有自己的回收机制,不用手动释放内存。
添加节点
LeetCode 203. 移除链表元素
力扣题目链接
题目描述:给你一个链表的头节点 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
输出:[]
提示:
列表中的节点数目在范围 [0, 10^4] 内
1 <= Node.val <= 50
0 <= val <= 50
- 本题遍历所有的节点进行删除即可
- 但注意到删除头节点和删除中间节点的操作是不一样的
- 可以在头节点前添加一个虚拟头节点,这样后面删除的操作就都一样了
代码如下:
# 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)
current = dummy_head
while current.next:
if current.next.val == val:
current.next = current.next.next
else:
current = current.next
return dummy_head.next
LeetCode 707. 设计链表
力扣题目链接
题目描述:你可以选择使用单链表或者双链表,设计并实现自己的链表。
单链表中的节点应该具备两个属性: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
的节点。
示例
输入
["MyLinkedList", "addAtHead", "addAtTail", "addAtIndex", "get", "deleteAtIndex", "get"]
[[], [1], [3], [1, 2], [1], [1], [1]]
输出
[null, null, null, null, 2, null, 3]
本题要求设计链表的五个接口:
- 获取链表第index个节点的数值
- 在链表的最前面插入一个节点
- 在链表的最后面插入一个节点
- 在链表第index个节点前插入一个节点
- 删除链表的第index个节点
注意,在起始位置加入一个虚拟头节点,可以简化操作,这也是链表的常用操作。
代码如下:
# 单链表法
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
cur = self.dummy_head.next
for i in range(index):
cur = cur.next
return cur.val
def addAtHead(self, val: int) -> None:
self.dummy_head.next = ListNode(val=val, next=self.dummy_head.next)
self.size += 1
def addAtTail(self, val: int) -> None:
cur = self.dummy_head
while cur.next:
cur = cur.next
cur.next = ListNode(val=val)
self.size += 1
def addAtIndex(self, index: int, val: int) -> None:
if index < 0 or index > self.size:
return
cur = self.dummy_head
for i in range(index):
cur = cur.next
newNode = ListNode(val=val)
newNode.next = cur.next
cur.next = newNode
self.size += 1
def deleteAtIndex(self, index: int) -> None:
if index < 0 or index >= self.size:
return
cur = self.dummy_head
for i in range(index):
cur = cur.next
cur.next = cur.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)
LeetCode 206. 反转链表
力扣题目链接
题目描述:给你单链表的头节点 head
,请你反转链表,并返回反转后的链表。
示例1:
输入:head = [1,2,3,4,5]
输出:[5,4,3,2,1]
示例2:
输入:head = [1,2]
输出:[2,1]
示例 3:
输入:head = []
输出:[]
提示:
链表中节点的数目范围是 [0, 5000]
-5000 <= Node.val <= 5000
本题可以使用双指针的方法,定义一个cur指针指向头节点,再定义一个prev指针初始化为null,开始反转时,
- 先将
cur.next
用temp
保存一下,因为此时我们想把prev
挂在cur
后面 - 将
prev
挂在cur
后面,cur.next = prev
- 移动
prev
指针到cur
- 移动
cur
到temp
- 接下来循环直到
cur == None
,此时prev
指向的就是反转后的链表。
代码如下:
# 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]:
prev = None
cur = head
while cur:
temp = cur.next
cur.next = prev
prev = cur
cur = temp
return prev
今日毕