代码随想录算法训练营第三日| LC203移除链表元素， LC707设计链表， LC206反转链表

LC203移除链表元素：

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

先判断头节点的值是否等于val，然后定义一个current节点。当cur的下一个节点为val时，将cur next删除。

LC707设计链表：

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

class MyLinkedList:

    def __init__(self):
        self._head = Node(0)
        self._count = 0

    def get(self, index: int) -> int:
        if 0 <= index < self._count:
            node = self._head
            for _ in range(index + 1):
                node = node.next
            return node.val
        else:
            return -1

    def addAtHead(self, val: int) -> None:
        self.addAtIndex(0, val)

    def addAtTail(self, val: int) -> None:
        self.addAtIndex(self._count, val)

    def addAtIndex(self, index: int, val: int) -> None:
        if index < 0:
            index = 0
        elif index > self._count:
            return
        self._count += 1
        add_node = Node(val)
        prev_node, cur_node = None, self._head
        for _ in range(index + 1):
            prev_node, cur_node = cur_node, cur_node.next
        else:
            prev_node.next, add_node.next = add_node, cur_node

    def deleteAtIndex(self, index: int) -> None:
        if 0 <= index < self._count:
            self._count -= 1
            prev_node, cur_node = None, self._head
            for _ in range(index + 1):
                prev_node, cur_node = cur_node, cur_node.next
            else:
                prev_node.next, cur_node.next = cur_node.next, None

LC206反转链表：

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和cur，pre指向当前链表头节点的前一位，cur指向头节点。然后先将cur的下一个节点储存为temp后再进行反转的操作。pre和cur都要向前移，最后pre会指向原最后一个节点，即新的头节点。