《代码随想录》Day3
1. 链表介绍
链表特性
- 链表 ListNode是由指针将多个节点串联在一起的线性结构,每个节点由两部分组成,一是当前节点值,二是下一节点(也就是指针)
- 链表的入口节点称为头节点也就是head
- 数组是在内存中是连续分布的,但链表中的节点在内存中不是连续分布的 ,而是散乱分布在内存中的某地址上,分配机制取决于操作系统的内存管理。
不同链表类型
-
单链表:如上所述,单链表中指针只能指向下一节点
-
双链表:每个节点有两个指针,分别指向上一节点和下一节点
-
循环链表:链表首尾相连
链表的操作
- 定义链表
class ListNode:
def __init__(self, val, next=None):
self.val = val
self.next = next
- 删除节点
若删除第一个元素/链表表头的值
if head.val == val:
return head.next
- 添加节点
2. Q203.移除链表元素
删除链表中等于给定值 val 的所有节点
分为删头节点和删非头节点
- 删头节点:使head = head.next
- 删非头节点:使head.next = head.next.next
class Solution:
def removeElements(self, head: ListNode, val: int) -> ListNode:
#判断要删除的是否是头节点:
while head and head.val == val:
#head不为none且head值等于val,此时要删除头节点
head = head.next
if head is None: #此时代表链表已全部删完
return head
#若要删除非头节点,则使该节点前一项.next = 该节点前一项.next.next
node = head #定义一个临时指针
while node.next : #while head.next不为none
if node.next.val == val: #删除非头节点
node.next = node.next.next
else:
node = node.next #不删,接着往后走
return head
虚拟头节点
在原链表前加上一个虚拟头节点来构建一个新链表,这样判断时就不用区别删除的是否是头节点,可以用一种方式处理完整个链表,输出时输出*dummyhead.next()*即可
class Solution:
def removeElements(self, head: ListNode, val: int) -> ListNode:
dummyhead = ListNode()
dummyhead.next = head
node = dummyhead
while node.next:
if node.next.val == val:
node.next = node.next.next
else:
node = node.next
return dummyhead.next
递归方法
class Solution:
def removeElements(self, head: Optional[ListNode], val: int) -> Optional[ListNode]:
if head is None: #先定义好边界
return head
head.next = self.removeElements(head.next,val) #使用递归函数
#相当于利用递归快速到达链表尾端,从后往前依次进行判断,用删除头节点的方式依次删除
#每次递归返回的时当前递归层的head(若head值不等于val),或head.next(若当前head值等于val)
if head.val == val: #若当前head值等于val
head = head.next
else: #若head值不等于val
head = head
return head
3. Q707.设计链表
在链表类中实现这些功能:
- get(index):获取链表中第 index 个节点的值。如果索引无效,则返回-1。
- addAtHead(val):在链表的第一个元素之前添加一个值为 val 的节点。插入后,新节点将成为链表的第一个节点。
addAtTail(val):将值为 val 的节点追加到链表的最后一个元素。 - addAtIndex(index,val):在链表中的第 index 个节点之前添加值为 val 的节点。如果 index 等于链表的长度,则该节点将附加到链表的末尾。如果 index 大于链表长度,则不会插入节点。如果index小于0,则在头部插入节点。
- deleteAtIndex(index):如果索引 index 有效,则删除链表中的第 index 个节点。
初始化设定
- 在虚拟头节点设定下进行操作
- 设置一个链表长度的属性,便于后续操作
class MyLinkedList:
def __init__(self,x=0): #链表初始化
#self.dummyhead = ListNode()
#self.dummyhead.next = head
self.head = Node() #设定head为虚拟头节点
self.size = 0 # 设置一个链表长度的属性,便于后续操作,注意每次增和删的时候都要更新
get(index) : 获取节点值
- 先讨论边界,若index超出链表范围的情况
- 利用一个临时指针 node 来遍历链表,node 一层层往后推,index 也一层层变小,直到 index=0 时返回该层node的值
def get(self, index: int) -> int:
#遍历链表获取第n个节点值
if index < 0 or index >= self.size: #若index超出链表范围,则返回-1
return -1
node = self.head.next
# 若index减为0,则跳出循环,返回该值,所以是在while中将指针node一点点往后推,直到index减为0
while (index): #若index不为0
node = node.next #往后推一层
index -= 1
return node.val
addAtHead(self, val) :插入头节点
注意:
- 此时是在虚拟头节点下讨论
- 且要及时更新self.size
def addAtHead(self, val: int) -> None:
#self.node此时为 dummy+原head
new_node = ListNode(val)
new_node.next = self.head.next #new_node此时为 val+原head
self.head.next = new_node #self.node此时为 dummy+val+原head
self.size += 1 #更新self.size
addAtTail(self, val):插入尾节点
- 需要用临时指针来帮助找尾巴的位置
- 尾巴时next.val = None
def addAtTail(self, val: int) -> None:
#self.node此时为 dummy+原head
new_node = ListNode(val)
#要找尾巴的位置,尾巴时next.val = None
node = self.head
while (node,next): #当node.next不为None,即还没到末尾
node = node.next #没到末尾就还往后挪
node.next = new_node #跳出循环,即找到末尾,现在就插入值
self.size += 1
addAtIndex(index,val): 在index前插入节点,节点值为val
- 需要先讨论index的取值情况
- 也是用临时指针来移到index位置,注意要将新节点插入index前,则指针要指到index-1的位置
def addAtIndex(self, index: int, val: int) -> None:
if index < 0: #此时插入为头结点
self.addAtHead(val)
return
elif index == self.size: #此时插入尾节点
self.addAtTail(val)
return
elif index > self.size: #此时不插入,直接返回
return
#利用临时指针node找到对应插入位置
new_node = ListNode(val)
node = self.head
while (index): #当index不为0
node = node.next
index -= 1
new_node.next = node.next
node.next = new_node
self.size += 1
deleteAtIndex(index): 删除链表中的第 index 个节点
def deleteAtIndex(self, index: int) -> None:
if int < 0 or int >= self.size:
return
node = self.head
while (index):
node = node.next
index -= 1
node.next = node.next.next
self.size -= 1
4. Q206.反转链表
反转一个单链表
双指针法
反转单链表可理解为依次将链表中箭头转向,用cur和pre两个指针,cur在pre之后,依次将箭头由cur指向pre
分为
class Solution:
def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
#定义两指针
cur = head
pre = None
while (cur): #当cur不等于None
temp = cur.next #将待处理链表暂时储存
cur.next = pre #转向
pre = cur #已转向的定为pre组
cur = temp #未处理的放在cur组中
return pre
递归法
思路和双指针法类似,用递归的一层层计算来代替while的一层层循环
class Solution:
def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
#先定义一个reverse函数,思路和双指针法类似
def reverse(cur,pre):
if cur is None:
return pre
temp = cur.next #将待处理链表暂时储存
cur.next = pre #转向
#此时要进入下一层循环,相当于while循环中的下一层
return reverse(cur=temp,pre=cur) #再用一遍reverse
return reverse(cur = head, pre = None) ##同双指针中的pre和cur的初始化定义