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

链表理论基础

链表是一种通过指针串联在一起的线性结构，每一个节点由两部分组成，一个是数据域一个是指针域（存放指向下一个节点的指针），最后一个节点的指针域指向null（空指针的意思）

数组是在内存中是连续分布的，但是链表在内存中可不是连续分布的。链表是通过指针域的指针链接在内存中各个节点。所以链表中的节点在内存中不是连续分布的 ，而是散乱分布在内存中的某地址上，分配机制取决于操作系统的内存管理。

链表的定义

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

203.移除链表元素

移除元素，添加哑结点，方便处理第一个元素。

刚写的时候没有将cur = cur.next放在else中，导致程序报错了，如果在找到值并删除后，cur继续向前移动，那么cur.next就没有被检查，因此在相等的情况下是不需要这一步的。

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

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.length = 0

    def get(self, index: int) -> int:
        if self.length <= index:
            return -1
        cur = self.dummy_head.next
        while index > 0:
            cur = cur.next
            index -= 1
        return cur.val

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

    def addAtTail(self, val: int) -> None:
        cur = self.dummy_head
        while cur.next:
            cur = cur.next
        cur.next = ListNode(val)
        self.length += 1

    def addAtIndex(self, index: int, val: int) -> None:
        if index > self.length:
            return
        cur = self.dummy_head
        while index > 0:
            cur = cur.next
            index -= 1
        cur.next = ListNode(val, cur.next)
        self.length += 1

    def deleteAtIndex(self, index: int) -> None:
        if index >= self.length:
            return
        cur = self.dummy_head
        while index > 0:
            cur = cur.next
            index -= 1
        cur.next = cur.next.next
        self.length -= 1

206.反转链表

迭代法

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

递归法是建立在上面迭代法的基础上的，可以先写出迭代法再写递归法

class Solution:
    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
        return self.reverse(None, head)

    def reverse(self, pre, cur):
        if cur is None:
            return pre
        next = cur.next
        cur.next = pre
        return self.reverse(cur, next)