一、移除链表元素
1.1 题目
给你一个链表的头节点 head
和一个整数 val
,请你删除链表中所有满足 Node.val == val
的节点,并返回 新的头节点 。
1.2 题目链接
1.3 代码
# 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]:
# 为便于处理,先虚拟一个头结点
fasle_head = ListNode(next = head)
p = fasle_head
while p.next :
# 因需要在找到目的结点后继续判断后一个结点,在满足要求的情况继续判断结点(if)
if p.next.val == val:
# 其实此处不需要q,但其他语言需要释放内存,所以此处保留
q = p.next
p.next = q.next
else:
p = p.next
return fasle_head.next
1.4 感想
比较常规,就是普通的循环+筛选替换,此类题目就是要注意边界!!!
二、设计链表
2.1 题目
1)你可以选择使用单链表或者双链表,设计并实现自己的链表。
2)单链表中的节点应该具备两个属性:val
和 next
。val
是当前节点的值,next
是指向下一个节点的指针/引用。
3)如果是双向链表,则还需要属性 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
的节点。
2.2 题目链接
2.3 代码
# 先定义单链表结点结构
class LNode:
def __init__(self,val = 0,next = None):
self.val = val
self.next = next
class MyLinkedList:
# 初始化时,设置单链表的长度
def __init__(self):
self.dummy_head = LNode()
self.size = 0
def get(self, index: int) -> int:
if index >= 0 and index < self.size:
p = self.dummy_head.next
for i in range(index):
p = p.next
return p.val
else:
return -1
def addAtHead(self, val: int) -> None:
p = LNode(val,self.dummy_head.next)
self.dummy_head.next = p
self.size += 1
def addAtTail(self, val: int) -> None:
q = LNode(val)
p = self.dummy_head
while p.next:
p = p.next
p.next = q
self.size += 1
def addAtIndex(self, index: int, val: int) -> None:
# 按索引位置添加元素时,索引值可等于添加前的链表长度
if index >= 0 and index <= self.size:
q = LNode(val)
p = self.dummy_head
for i in range(index):
p = p.next
q.next = p.next
p.next = q
self.size += 1
def deleteAtIndex(self, index: int) -> None:
if index >= 0 and index < self.size:
p = self.dummy_head
for i in range(index):
p = p.next
q = p.next
p.next = q.next
self.size -= 1
else:
return
# 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)
2.4 感想
关于链表的基础函数,比较考细节,一些边界问题。
1)按索引插入元素,插入的位置可以等于现有长度;
2)python自带内存回收,但是c++没有内存回收,需要手动释放;
3)循环的条件到最后会不会碰到空指针,如果碰上又要如何处理;
4)删除中间结点前,需先存储后续结点的地址。
三、反转链表
3.1 题目
给你单链表的头节点 head
,请你反转链表,并返回反转后的链表。
3.2 题目链接
3.3 代码
3.3.1 原地逆转链表
# 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
# 前指针
p = head
# 后指针
q = head.next
while q :
# 取出后一个结点
p.next = q.next
# 将新结点以头插法原地插入链表
q.next = head
head = q
# 更新后结点
q = p.next
return head
3.3.2 双指针
# 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]:
# 双指针:用两个指针,逆转单链表的方向
# 前指针:初始值应该是None,也就是最后单链表的尾端
pre = None
# 后指针:从头结点开始
cur = head
while cur:
# 处理之前,先保存后指针的地址
temp = cur.next
# 逆转两个结点之间的方向
cur.next = pre
# 更新pre指针(左端的新方向的头结点)和cur指针(右端的方向的第一个待处理结点)
pre = cur
cur = temp
return pre
3.3.3 递归
# 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,cur:ListNode,pre:ListNode) -> ListNode:
# 循环终止的出口
if cur == None:
return pre
# 简单化步骤过程:调转一个+调转其他部分
# 记录右端的起点
temp = cur.next
# 调转方向
cur.next = pre
# 转向其他部分:“cur” = temp,"pre" = cur
return self.reverse(temp,cur)
3.4 感想
看到链表的反转,第一想法就是原地头插法,没有太往双指针和其他方向去想。