代码随想录｜Day03｜链表01｜203. 移除链表元素、707. 设计链表、206. 反转链表

203. 移除链表元素

链表基础题，但有许多值得讨论的点。

1. 链表的删除操作比较特殊，删除第 n 个节点需要通过操作上一个节点 n - 1 实现。这由链表的性质决定，其内存并不如数组那样是连续的，而是通过各节点中保存的指针，连接零散的内存，如链子一般。举例来说，一个节点除了包含值 val，还包含了一个指针 next，其指向下一个节点，最后一个节点的指针指向 None，表示链表的结束。因此，若不遍历链表，无法得知链表长度，若想要到达某节点，只能通过从头遍历实现。

2. 头节点没有上一个节点，如何删除？创建虚拟头节点！如此一来头节点便和其他节点一样，可采用相同的操作逻辑，而无需特殊处理。

# 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]:
        # 创建虚拟头节点，值为0，指向链表头节点
        dummy_head = ListNode(0, head)

        # 创建指针cur，对链表进行操作
        cur = dummy_head
        
        # 为什么循环条件为 cur.next != None，而不是 cue != None
        # 如之前所说，删除当前节点需要操作上一个节点
        # 考虑边界，若要删除末尾节点，需要操作倒数第二个节点
        # 跳出条件为 cur.next == None，此时cur指向最后一个节点，而我们无需操作最后一个节点
        while cur.next:
            if cur.next.val == val:
                cur.next = cur.next.next
            else:
                cur = cur.next

        # 为什么返回 dummy_head.next，而不直接返回 head
        # 因为原头节点可能被删除了
        return dummy_head.next
# 时间复杂度：
# O(n)

707. 设计链表

自行设计链表的基础操作，对理解链表有极大的帮助，同时也考察类 (class) 相关知识点。

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 - 1:
            return -1

        cur = self.dummy_head.next
        # 为什么不是 index + 1 ?
        # cur指向实际头节点，假如寻找 index == 2，也就是第3个节点
        # cur需要移动 2次
        # 故为 range(index)
        for i in range(index):
            cur = cur.next
        return cur.val

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

    def addAtTail(self, val: int) -> None:
        new_tail = ListNode(val = val, next = None)
        cur = self.dummy_head
        # 为什么不是 cur?
        # 需要遍历到原链表最后一个节点，然后指向新加入的节点
        # cur.next == None，说明 cur 指向最后一个节点
        # cur == None，说明 cur 跳出链表外
        # 故循环条件为 while cur.next
        while cur.next:
            cur = cur.next
        cur.next = new_tail
        self.size += 1

    def addAtIndex(self, index: int, val: int) -> None:
        if index < 0 or index > self.size:
            return
        # 插入到下标为 index 的节点之前，意味着新节点下标为 index
        # 所以操作的节点下标为 index - 1

        # 这里是虚拟头节点发挥作用的情况
        # 假设 index == 0，则新节点 index == 0，需要操作头节点之前的节点
        # 在这里构建虚拟头节点，将无需对实际头节点进行特殊判断
        cur = self.dummy_head

        # cur指向虚拟头节点，假设在 index == 2 的节点前插入新节点
        # 新节点 index == 2，需要操作 index == 1的节点
        # cur需要移动 2次
        for i in range(index):
            cur = cur.next
        # cur指向新插入的节点，而新节点指向 cur 原本指向的节点 (cur.next)
        cur.next = ListNode(val = val, next = cur.next)
        self.size += 1

    def deleteAtIndex(self, index: int) -> None:
        if index < 0 or index > self.size - 1:
            return
        # 同理，删除下标为 index 的节点，需要操作下标为 index - 1的节点
        # 为了避免对头节点进行特殊处理，构造虚拟头节点
        cur = self.dummy_head

        # cur指向虚拟头节点，假设删除 index == 2 的节点，
        # 需要操作 index == 1 的节点
        # cur需要移动 2次
        for i in range(index):
            cur = cur.next
        cur.next = cur.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)

206. 反转链表

双指针

反转所有节点的指针指向，听起来很简单，但实际操作可能有点烧脑，容易转晕。

每次反转，我们需要操作三个指针：

prev、cur、next分别指向前一个、当前、下一个节点，

我们要做的是将 cur 指向 next，反转为 cur 指向 prev。

注意，反转后，原头节点变为末节点，需要指向 None，因此 prev 初始化为 None，cur 初始化为 head，next 则直接使用 cur.next。

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:

        prev, cur = None, head
        # 为什么不是 cur.next？
        # cur.next == None 意味着 cur 指向 末节点
        # 但我们需要修改末节点的指针，此时如果跳出，则未完成反转
        while cur:
            # 将 cur 指向 next 反转为 cur 指向 prev
            # 我们使用 next 将 cur 指向 next 保存，否则会丢失 cur 下一个节点的访问
            next = cur.next
            cur.next = prev
            # 反转完成后，prev, cur 分别前进一步
            # prev 移动到当前节点 cur
            # cur 移动到下一节点 cur.next
            prev = cur
            cur = next
        # 当反转完成，cur == None 跳出循环，意味着 cur 跳出了链表
        # 此时 prev 指向原链表末节点，也就是新链表头节点
        return prev

递归

递归是一种更为优雅的表达方式，其逻辑和双指针一致，只不过采用了“自己调用自己”的方式来表达。

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
        # 递归
        return self.reverse(head, None)
    
    def reverse(self, cur: ListNode, prev: ListNode):
        # 递归结束条件
        if cur == None:
            return prev
        # 递归本体
        next = cur.next
        cur.next = prev
        # 将 cur 和 prev 各向前移一步
        # 双指针代码：cur = next, prev = cur
        # 思考他们之间的联系，此为递归的精髓所在
        return self.reverse(next, cur)