代码随想录算法训练营第三天|203.移除链表元素、707.设计链表、206.反转链表

203.移除链表元素

题目链接:203.移除链表元素
思路：这题蛮简单的，移除操作，就让节点next指针直接指向下下一个节点就可以了，但因为单链表的特殊性，只能指向下一个节点，那么如果删除的是头结点又该怎么办呢？这里就涉及如下链表操作的两种方式：

• 直接使用原来的链表来进行删除操作。
• 设置一个虚拟头结点在进行删除操作。

原链表进行操作

代码如下：

class Solution:
    def removeElements(self, head: Optional[ListNode], val: int) -> Optional[ListNode]:
        current = ListNode(next=head)
        while head != None and head.val == val:
            head = head.next
        while current.next:
            if current.next.val == val:
                current.next = current.next.next
            else:current = current.next
        return head

• 时间复杂度O(n)
• 空间复杂度O(1)

设置虚拟头结点进行操作

代码如下：

class Solution:
    def removeElements(self, head: Optional[ListNode], val: int) -> Optional[ListNode]:
        dummy_head = ListNode(next = head)
        current = dummy_head
        while current.next:
            if current.next.val == val:
                current.next = current.next.next
            else:current = current.next
        return dummy_head.next

• 时间复杂度O(n)
• 空间复杂度O(1)

学习时长
20分钟

707.设计链表

题目链接：707.设计链表

用虚拟头结点来操作

代码如下：

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next
class MyLinkedList:

    def __init__(self):
        self.dummy_head = ListNode()
        self.size = 0

    def get(self, index: int) -> int:
        if index < 0 or index >= self.size:
            return -1
        cur = self.dummy_head
        for i in range(index):
            cur = cur.next
        return cur.val

    def addAtHead(self, val: int) -> None:
        cur = self.dummy_head
        cur.next = ListNode(val, cur.next)
        self.size += 1

    def addAtTail(self, val: int) -> None:
        cur = self.dummy_head
        for i in range(self.size):
            cur = cur.next
        cur.next = ListNode(val)
        self.size += 1

    def addAtIndex(self, index: int, val: int) -> None:
        if index < 0 or index > self.size:
            return
        cur = self.dummy_head
        for i in range(index):
            cur = cur.next
        cur.next = ListNode(val, cur.next)
        self.size += 1

    def deleteAtIndex(self, index: int) -> None:
        if index < 0 or index >= self.size:
            return
        cur = self.dummy_head
        for i in range(index):
            cur = cur.next
        cur.next = cur.next.next
        self.size -= 1

学习时长
1小时

206.反转链表

题目链接:206.反转链表
思路：首先定义一个cur指针，指向头结点，再定义一个pre指针，初始化为null。然后就要开始反转，先要把 cur->next 节点用temp指针保存一下，接下来要改变 cur->next 的指向，将cur->next 指向pre ，此时已经反转了第一个节点了。接下来，就是循环之前的逻辑，继续移动pre和cur指针。最后，当cur 指针指向了null，循环结束，链表也反转完毕了。 此时return pre指针就可以了，pre指针就指向了新的头结点。

双指针法

代码如下：

class Solution:
    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
        pre = None
        current = head
        while current :
                temp = current.next
                current.next = pre
                pre = current
                current = temp
        return pre

• 时间复杂度O(n)
• 空间复杂度O(1)

递归法

class Solution:
    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
        return  self.reverselist(head,None)
    def reverselist(self,cur:ListNode,pre:ListNode) ->ListNode:
        if cur == None:
            return pre
        temp = cur.next
        cur.next = pre
        return self.reverselist(temp,cur)

• 时间复杂度O(n)
• 空间复杂度O(n)

递归法其实和双指针法是一样的逻辑，只不过写法变了。可以看到双指针法中初始化 cur = head，pre = NULL，在递归法中可以看出初始化的逻辑也是一样的。同样是当cur为空的时候循环结束，不断将cur指向pre的过程。
学习时长
30分钟

今日小结

707 设计链表看了比较久的时间，看得我脑壳发胀，感觉要长脑子了