Day03

Day03 代码随想录刷题

知识点：链表、虚拟头结点、链表指针

一、LeetCode203.移除链表元素

1.解题思路

考点为虚拟头结点和链表指针的应用

2.代码实现

设计虚拟头结点yhead连接原链表表头head，同时设计一个指针cur遍历列表，指针cur每次前进都需要判断cur.next是否为None。过程中，如果指针cur下一节点是要删除的值：cur.next.val == val，则指针cur指向下下节点：cur.next = cur.next.next。

class Solution:
    def removeElements(self, head: Optional[ListNode], val: int) -> Optional[ListNode]:

        yhead = ListNode(next = head)
        cur = yhead
        while cur.next != None:
            if cur.next.val == val:
                cur.next = cur.next.next
            else:
                cur = cur.next
        return yhead.next

指针cur遍历了一遍整个链表，所以时间复杂度:为O(n)，空间复杂度 O(1)。

一、LeetCode206.反转链表

1.解题思路

考点为链表指针，通过双指针pre和cur和临时节点指针temp实现链表的反转

2.代码实现

2.1 方法一：迭代法

class Solution:
    # 迭代法
    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
        cur = head
        pre = None
        while cur:
            temp = cur.next # 储存当前的next
            cur.next = pre
            pre = cur
            cur = temp
        return pre

该解法时间复杂度:为O(n)，空间复杂度 O(1)。

2.2 方法二：递归法

class Solution:
    # 递归法

    # 递归中不变的逻辑函数
    def reverse(self, pre, cur):
        if not cur: # cur为None时停止迭代
            return pre
        temp = cur.next
        cur.next = pre # 储存当前的next
        # 下面实现：
        #  pre = cur
        #  cur = temp
        return self.reverse(cur,temp)
        
    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
        return self.reverse(None, head)

该解法要递归处理链表的每个节点，所以时间复杂度为O(n)；

关于递归法的空间复杂度，通常会涉及到系统栈空间的使用。每一层递归调用都会将当前的状态压入栈中，等待递归调用返回后再弹出。在反转链表的递归实现中，如果链表的长度为 n，则会有 n 层递归调用。这意味着，在进行递归调用时，将使用 n 层栈空间来存储每一层的状态。因此，递归法的空间复杂度是 O(n)

三、LeetCode707.设计链表

1.解题思路

据题意通过单链表和双向链表分别实现链表的插入、删除等操作，考点在于理解链表的结构和操作方法。

2.代码实现

2.2 方法一：单链表实现

单链表每个节点都有意义，为了方便操作，一般会创建虚拟头结点和链表指针用于操作。注意事项：

单链表从虚拟头yhead结点出发，按照索引index走，到不了索引所在位置，会处于前一个节点

# 1.单链表的初始化，默认：
#   [  val  |  next ]
#   [   0   |  next ]
class ListNode:
    def __init__(self,val = 0,next = None):
        self.val = val
        self.next = next
# 2.链表实现各个操作的类
class MyLinkedList:
    # 2.1链表初始化：创建虚拟头结点
    def __init__(self):
        self.yhead = ListNode()
        self.cnt = 0
    # 2.2从链表中取出索引为index的节点的val值
    def get(self, index: int) -> int:
        if index < 0 or index >= self.cnt:
            return -1
        cur = self.yhead.next
        for _ in range(index):
            cur = cur.next
        return cur.val
    # 2.3在链表头插入一个值为val的节点
    def addAtHead(self, val: int) -> None:
        self.addAtIndex(0,val)
    # 2.4在链表尾插入一个值为val的节点
    def addAtTail(self, val: int) -> None:
        self.addAtIndex(self.cnt,val)
    # 2.5在链表索引为index的节点处插入一个值为val的新节点
    def addAtIndex(self, index: int, val: int) -> None:
        if index < 0 or index > self.cnt:
            return
        pre = self.yhead
        for _ in range(index):
            pre = pre.next
        pre.next = ListNode(val,pre.next)
        self.cnt += 1
    # 2.6删除链表中索引为inde的节点
    def deleteAtIndex(self, index: int) -> None:
        if index < 0 or index >= self.cnt:
            return
        pre = self.yhead
        for _ in range(index):
            pre = pre.next
        pre.next = pre.next.next
        self.cnt -= 1

2.2 方法二：双向链表实现

双向链表会牺牲2个节点的空间来作为节点head和节点tail，这2个节点首尾相连，充当双向链表的头和尾，用于下标索引的规范（其作用类似单链表的虚拟头结点）。主意事项：

从头结点head出发，按照索引index走，到不了索引所在位置，会处于其前一个节点

从尾结点tail出发，按照索引size - index走，刚好能到索引的位置。

# 1.双向链表的初始化，默认:
#   [ prev  |  val  |  next ]
#   [ None  |   0   |  None ]
class ListNode:
    def __init__(self, val= 0, prev = None, next = None):
        self.val = val
        self.prev = prev
        self.next = next
# 2.链表实现各个操作的类
class MyLinkedList:
    # 2.1链表头尾节点初始化
    def __init__(self):
        self.size = 0
        self.head = ListNode() 
        self.tail = ListNode()
        self.head.next = self.tail
        self.tail.prev = self.head
    # 2.2从链表中取出索引为index的节点的val值
    def get(self, index: int) -> int:
        if index < 0 or index >= self.size:
            return -1
        if index < self.size//2:
            cur = self.head.next
            for _ in range(index):
                cur = cur.next
        else:
            cur = self.tail
            for _ in range(self.size - index):
                cur = cur.prev
        return cur.val
    # 2.3在链表头插入一个值为val的节点
    def addAtHead(self, val: int) -> None:
        self.addAtIndex(0, val)
    # 2.4在链表尾插入一个值为val的节点
    def addAtTail(self, val: int) -> None:
        self.addAtIndex(self.size, val)
    # 2.5在链表索引为index的节点处插入一个值为val的新节点
    def addAtIndex(self, index: int, val: int) -> None:
        if index < 0 or index > self.size:
            return
        if index < self.size//2:
            pre = self.head
            for _ in range(index):
                pre = pre.next
            cur = pre.next
        else:
            cur = self.tail
            for _ in range(self.size - index):
                cur = cur.prev
            pre = cur.prev

        pre.next = ListNode(val,pre,cur)
        cur.prev = pre.next
        self.size += 1
    # 2.6删除链表中索引为index的节点
    def deleteAtIndex(self, index: int) -> None:
        if index < 0 or index >= self.size:
            return
        if index < self.size//2:
            pre = self.head
            for _ in range(index):
                pre = pre.next
            cur = pre.next
        else:
            cur = self.tail
            for _ in range(self.size - index):
                cur = cur.prev
            pre = cur.prev
        
        pre.next = cur.next
        cur.next.prev = pre
        self.size -= 1