代码随想录二刷(链表章节)
代码随想录二刷(链表章节)
链表就是通过指针串联在一起的线性结构,每个节点都是由一个数据域和指针域(存放下一个节点的指针)。
双链表就是每个节点中既有指向前一个节点的,也有指向后一个节点的。
循环链表就是把头和尾连起来。
性能分析如下:
下面来看下链表的具体题目:
Leetcode203
这里首先要明白处理链表一个技巧就是可以创立一个哨兵节点。这样就能避免处理一些特殊情况,比如只有头的情况下。这样的话,链表始终是有一个元素的。具体来说过程如下图
# @lc code=start
# 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 = ListNode(next = head)
cur = dummy
while cur.next:
if cur.next.val == val:
cur.next = cur.next.next
else:
cur = cur.next
return dummy.next
Leetcode707
具体程序如下:
class Listnode:
def __init__(self, val=0, next=None):
self.val = val
self.next = next
class MyLinkedList:
def __init__(self):
self.dummy = Listnode()
self.size = 0
def get(self, index: int) -> int:
if index < 0 or index >= self.size:
return -1
cur = self.dummy
while cur.next:
if index == 0:
return cur.next.val
cur = cur.next
index -= 1
def addAtHead(self, val: int) -> None:
cur = self.dummy
cur.next = Listnode(val,cur.next)
self.size += 1
def addAtTail(self, val: int) -> None:
cur = self.dummy
while cur.next:
cur = cur.next
cur.next = Listnode(val)
self.size += 1
def addAtIndex(self, index: int, val: int) -> None:
cur = self.dummy
if index > self.size or index < 0:
return
for _ in range(index):
cur = cur.next
cur.next = Listnode(val, cur.next)
self.size += 1
def deleteAtIndex(self, index: int) -> None:
cur = self.dummy
if index >= self.size or index < 0:
return
for _ in range(index):
cur = cur.next
cur.next = cur.next.next
self.size -= 1
首先分析get函数的实现:
由于题目要求下标是从0开始,所以要用个self.size记录下链表中元素的数量。那么插入头部和插入尾部以及删除指定Index,都会涉及到self.size的变化。
首先要把下标无效的情况给排除掉。也就是
if index < 0 or index >= self.size:
return -1
接下里操作链表的话都是要用哨兵节点(这样就可以将只有一个元素的特殊情况也给合并了)。用for循环遍历就可以:
cur = self.dummy
for _ in range(index):
cur = cur.next
return cur.next.val
插入到第一个元素之前,也就是插入到头之前。这时候就体会到哨兵节点的好用了。
cur.next = Listnode(val,cur.next)
cur代表哨兵节点,哨兵节点的下一个也就是头部的位置,所以创建一个值为val,并且这个节点为原来节点的下一个节点。这样就完成插入的操作了
删除操作的话 ,
所以还要先判断下标是否超范围:
if index >= self.size or index < 0:
return
然后接着for循环去根据index来。然后要删除的节点。
for _ in range(index):
cur = cur.next
所以删除:cur.next = cur.next.next
如果不明白的话。画个图就好理解下,做关于链表的题目。
插入操作的也可以画个图:
cur = self.dummy
if index > self.size or index < 0:
return
for _ in range(index):
cur = cur.next
cur.next = Listnode(val, cur.next)
下面来看下反转链表的题目。
这里采用双指针的思想,pre为该节点要指向的新位置,cur为当前要处理的节点。并且当前要处理的节点的下个位置的信息由于你改变了指向会丢失,所以要用临时变量temp给保存起来。这些操作完成后,pre移动到cur,然后cur移动到下个位置也就是pre的位置。
所以程序思路其实知道了双指针后,并不是很难写出来:
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
Leetcode24
下面来看下下道题两两交换的链表题目:
这个交换链表的也建议是画图的话更好去理解。
看着这个图去写程序就可以。
class Solution:
def swapPairs(self, head: Optional[ListNode]) -> Optional[ListNode]:
dummy_head = ListNode(next = head)
cur = dummy_head
pre = None
while cur.next and cur.next.next:
temp1 = cur.next
temp2 = cur.next.next.next
cur.next = cur.next.next
cur.next.next = temp1
cur.next.next.next = temp2
cur = cur.next.next
return dummy_head.next
但是while循环要注意不止要判断Cur.next,还要判断cur.next.next。因为程序里面都是两两交换的。
Leetcode19
继续一道倒着删除链表的题目:
这道题思路是用双指针的思路,因为要删除倒数第n个节点。而链表的话只能按顺序遍历,所以用一个快指针,一个慢指针。快指针先走n步,然后在快指针的基础上慢指针移动,终止条件是快指针到达末尾。这样慢指针停的位置就是刚好要删除节点的前面一个。
具体原理如下:
class Solution:
def removeNthFromEnd(self, head: Optional[ListNode], n: int) -> Optional[ListNode]:
dummy_head = ListNode(0,head)
slow,fast = dummy_head,dummy_head
for _ in range(n+1):
fast = fast.next
while fast:
slow = slow.next
fast = fast.next
slow.next=slow.next.next
return dummy_head.next
本文来自博客园,作者:Bathwind_W,转载请注明原文链接:https://www.cnblogs.com/bathwind/p/18333216