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

文档讲解：代码随想录

视频讲解：代码随想录B站账号

状态：看了视频题解和文章解析后做出来了

203.移除链表元素

第一步，要知道链表的定义方式：

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_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

这里我们首先设置了一个虚拟链表头，用于指向题目所给链表的头部，这样我们在删除第一个链表元素的时候，就不必特殊处理。

这里还要创建一个current链表，这个链表的内存地址和dummy_head相同，所以任何在current上做出的改变，在dummy_head也会体现。

• 遍历整个链表，如果当前指向的下一个链表存储着目标数值，则把当前链表指向下下个节点；
• 如果指向的非目标数值，则向前移动一位

707. 设计链表

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

class MyLinkedList:

    def __init__(self, val=0, next=None):
        self.dummy_head = ListNode()
        self.size = 0

    def get(self, index: int) -> int:
        if index < 0 or index >= self.size:
            return -1

        current = self.dummy_head.next
        for i in range(index):
            current = current.next
        
        return current.val

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


    def addAtTail(self, val: int) -> None:
        current = self.dummy_head
        while current.next:
            current = current.next

        current.next = ListNode(val = val)
        self.size += 1
        

    def addAtIndex(self, index: int, val: int) -> None:
        if index < 0 or index > self.size:
            return

        current = self.dummy_head
        for i in range(index):
            current = current.next

        current.next = ListNode(val = val, next = current.next)
        self.size += 1
        

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

        current.next = current.next.next
        self.size -= 1
        


# 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)

仍然使用虚拟链表头作为链表的初始节点。

这里要注意，get链表节点值和删除链表的函数中，index是不能大于等于self.size，但是在添加链表的时候是可以的，因为我们可以选择在当前链表长度+1的地方添加元素。

另外current.next = ListNode(val = val, next = current.next) 的用法也十分精妙，在声明新链表的途中就把添加操作做好了。

最后，别忘了在链表长度有变化的函数下更新self.size。

206. 反转链表

class Solution:
    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
        pre = None
        cur = head

        while cur:
            temp = cur.next
            cur.next = pre
            pre = cur
            cur = temp

        return pre

思路其实很简单，设定一个pre变量，这个变量的值为空，也就是我们反转后head第一个节点要指向的节点，cur追踪当前节点的位置。

while的终止条件为cur不为空，也就是cur遍历到最后一个节点后再next为空，这时候就要终止循环。

需要用一个temp变量保存当前节点的下一个节点，因为我们马上要进行反转操作，如果不保存的话就无法再追踪到下一个节点。然后进行反转操作，最后将两个指针分别向右移动一格，直到循环结束。