题目:203. 移除链表元素
给你一个链表的头节点 head
和一个整数 val
,请你删除链表中所有满足 Node.val == val
的节点,并返回 新的头节点
。
涉及数据结构
- 链表
我的思路
- 单向链表按值删除元素
- 但是定义不好更新过程,有点乱,看解析视频
解法
移除链表
-
移除操作,就是让节点
next
指针直接指向下下一个节点 -
因为单链表的特殊性,只能指向下一个节点,如果删除的是头结点:
- 直接使用原来的链表来进行删除操作
- 头结点没有前一个节点 → 将头结点后移一位
head = head.next
- 头结点没有前一个节点 → 将头结点后移一位
- 设置一个虚拟头结点再进行删除操作【统一结点位置情况】
- 给链表添加一个虚拟头结点为新的头结点
- 直接使用原来的链表来进行删除操作
-
时间复杂度: O ( n ) O(n) O(n)
-
方法一:直接删除
# 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]:
if head == None:
return head
# else:
# p = head
# 更新应该在if里 所以分两种
# ① 一直遍历head
while head != None and head.val == val:
head = head.next
# ② 更新非head节点,要一直判断p.next.val是否等于val,直到不等于,就更新p = p.next
p = head
while p != None and p.next != None:
if p.next.val == val:
p.next = p.next.next
else:
p = p.next
return head
- 方法二:虚拟一个头节点
# 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]:
if head == None:
return head
vir_head = ListNode(0,head) # 虚拟节点指向头结点
p = vir_head
while p != None and p.next != None:
if p.next.val == val:
p.next = p.next.next
else:
p = p.next
return vir_head.next
效果、心得:
- 移除元素属于链表基本操作,要很熟练
- 个人理解:一般
p.next = p
是“指向”p
,p = p.next
是“更新”p
题目: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
的节点。
涉及数据结构
- 单/双向链表
我的思路
- 属于链表的常用操作的实现
- 链表初始化,要单向双向都有
- 按下标返回值
- 头插节点
- 尾插节点
- 指定位置插入节点
- 指定位置删除节点
解法
链表操作的两种思路
-
直接使用原来的链表来进行操作
-
设置一个虚拟头结点在进行操作
-
使用虚拟节点:
# 单链表
class ListNode():
def __init__(self, val):
self.val = val
self.next = None
class MyLinkedList:
def __init__(self):
self.vit_head = ListNode(0) #虚拟节点
self.size_ = 0
def get(self, index: int) -> int:
if index > self.size_ -1 or index < 0:
return -1
p = self.vit_head.next
for _ in range(index):
p = p.next
return p.val
def addAtHead(self, val: int) -> None:
p = ListNode(val)
p.next = self.vit_head.next
self.vit_head.next = p
#size要加1
self.size_ += 1
def addAtTail(self, val: int) -> None:
p = self.vit_head
while p.next:
p = p.next
tail = ListNode(val)
p.next = tail
self.size_ += 1
def addAtIndex(self, index: int, val: int) -> None:
if index < 0 or index > self.size_:
return
p = self.vit_head #与下标对应,p应该是index-1那个数
for _ in range(index):
p = p.next
cur = ListNode(val)
cur.next = p.next
p.next = cur
self.size_ += 1
def deleteAtIndex(self, index: int) -> None:
if index < 0 or index >= self.size_ :
return
p = self.vit_head
for _ in range(index):
p = p.next
p.next = p.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. 反转链表
给你单链表的头节点 head
,请你反转链表,并返回反转后的链表
涉及数据结构
- 单链表
我的思路
- 从前往后读成一个list,再用头插法创建链表
# 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]:
if head == None or head.next == None:
return head
nums = []
p = head
while p:
nums.append(p.val)
p = p.next
vir_head = ListNode(0) # 虚拟节点 方便头插
for num in nums:
node = ListNode(num)
node.next = vir_head.next
vir_head.next = node
return vir_head.next
解法
思路
-
上面方法是对内存空间的浪费,只需要改变链表的
next
指针的指向,直接将链表反转 ,而不用重新定义一个新的链表 -
双指针法:
cur, pre
两个指针依次向后,cur
指向pre
- 还需要临时指针保存未变向前
cur
的下一个节点 - 先移动
pre
后移动cur
-
递归法:
- 逻辑与双指针法一样
- 要注意停止条件
-
双指针法:时间复杂度: O ( n ) O(n) O(n)
# 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]:
cur = head
pre = None
while cur:
temp = cur.next
cur.next = pre
pre = cur
cur = temp
return pre
- 递归法:时间复杂度: O ( n ) O(n) O(n)
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, val=0, next=None):
# self.val = val
# self.next = next
class Solution:
def reverse(self, cur: ListNode, pre:ListNode) -> ListNode:
if cur == None:
return pre
temp = cur.next
cur.next = pre
return self.reverse(temp, cur)
def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
# cur = head
# pre = None
return self.reverse(head, None)
效果、心得:
- 链表题,感觉需要往“多用指针”的方向去想解法
- 双指针法比较好理解,逻辑清晰。递归还需要再熟练一下逻辑