算法训练Day03 | 203.移除链表元素、707.设计链表、206.反转链表

203.移除链表元素

题目链接：[203.移除链表元素-力扣（LeetCode）](https://leetcode.cn/problems/remove-linked-list-elements/description/

思路：easy，注意单独处理头节点，也可以在头节点前面接一个虚拟节点，即可将所有节点同时处理，若加虚拟节点，注意返回时需返回虚拟节点的下一个节点（真正的头节点）

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def removeElements(selfr, head: Optional[ListNode], val: int) -> Optional[ListNode]:
        
        node = ListNode(next=head)
        current_node = node
        while current_node.next:
            if current_node.next.val == val:
                current_node.next = current_node.next.next
            else:
                current_node = current_node.next
        return node.next

参考文章：代码随想录-203.移除链表元素

707.设计链表

题目链接：707.设计链表-力扣（LeetCode）

思路：实现思路很简单，但是需要注意很多细节，尤其初始化时建立是一个虚拟节点，还仅仅是一个空列表，尤其注意这点以及索引的变化

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

class MyLinkedList():

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

    def get(self, index: int) -> int:
        if index >= self.size or index <0:
            return -1
        count = 0
        temp_node = self.head.next
        while count != index:
            temp_node = temp_node.next
            count += 1
        return temp_node.val

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

    def addAtTail(self, val: int) -> None:
        new_node = ListNode(val=val)
        temp_node = self.head
        while temp_node.next:
            temp_node = temp_node.next
        temp_node.next = new_node
        self.size += 1

    def addAtIndex(self, index: int, val: int) -> None:
        if index <= self.size and index >=0:
            new_node = ListNode(val=val)
            pre_index = 0
            temp_node = self.head
            while pre_index != index:
                temp_node = temp_node.next
                pre_index += 1
            new_node.next = temp_node.next
            temp_node.next = new_node
            self.size += 1

    def deleteAtIndex(self, index: int) -> None:
        if index < self.size and index >=0:
            pre_index = 0
            temp_node = self.head
            while pre_index != index:
                temp_node = temp_node.next
                pre_index += 1
            temp_node.next = temp_node.next.next
            self.size -= 1

参考文章：代码随想录-707.设计链表

206.反转链表

题目链接：206.反转链表-力扣（LeetCode）

思路：实现起来比较容易，但需要注意内存管理，只需要新建一个临时节点就可以反转列表（我的实现方法反而粗糙了一些，后面更新一下

# 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]:
        old_head = ListNode(next=head)
        new_head = ListNode(next=None)
        while old_head.next:
            node = old_head.next
            old_head.next = node.next
            node.next = new_head.next
            new_head.next = node
        return new_head.next

参考文章：代码随想录-206.反转链表