203.移除链表元素 707.设计链表 206.反转链表

链表是一种通过指针串联在一起的线性结构, 链表在内存中可不是连续分布的, 链表是通过指针域的指针链接在内存中各个节点

链表的增添和删除都是O(1)操作，也不会影响到其他节点

链表的增添和删除都是O(1)操作，也不会影响到其他节点

• 链表插入/删除时间复杂度O(1), 查询时间复杂度O(n)
• 数组插入/删除时间复杂度O(n), 查询时间复杂度O(n)

定义链表

#Definition for singly-linked list.
class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

203.移除链表元素 

给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。

设置一个虚拟头结点 （注意不要操作空结点）

要想删除当前结点， 指针需要在当前结点的前一个结点

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

707.设计链表

注意初始化， 如果要操作第n个结点， 要先找到第n-1个结点

注意dummy_head的使用和cur的位置

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

class MyLinkedList:

    def __init__(self):
        self.dummy_head = Node(val=0)
        self._count = 0

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

    def addAtHead(self, val: int) -> None:
        new_node = Node(val)
        # 注意插入时候先后顺序
        new_node.next = self.dummy_head.next
        self.dummy_head.next = new_node
        self._count +=1

    def addAtTail(self, val: int) -> None:
        new_node = Node(val=val)
        cur = self.dummy_head
        while cur.next != None:
            cur = cur.next
        cur.next = new_node
        self._count += 1
        self._head = self.dummy_head.next

    def addAtIndex(self, index: int, val: int) -> None:
        if index < 0:
            index = 0
        elif index > self._count:
            return

        cur = self.dummy_head
        new_node = Node(val=val)
        for _ in range(index):
            cur = cur.next
        new_node.next = cur.next
        cur.next = new_node
        self._count += 1

    def deleteAtIndex(self, index: int) -> None:
        cur = self.dummy_head
        if 0 <= index < self._count:
            for _ in range(index):
                cur = cur.next
            cur.next = cur.next.next
            self._count -= 1

206.反转链表

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

只需要改变链表的next指针的指向，直接将链表反转

双指针或递归

双指针

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

递归

递归写法逻辑跟双指针一样， 要先掌握双指针写法

class Solution:
    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
        def reverse(cur, pre):
            if not cur:
                return pre
            tmp = cur.next
            cur.next = pre
            return reverse(tmp, cur)

        return reverse(head, None)