【Leetcode刷题Day3】代码随想录：203移除链表元素，707设计链表，206反转链表

203移除链表元素：

我们这里采用在原链表移除：如果是头节点，将其向后移动一位；如果不是头节点，节点下一个指针指向下下个节点

class Solution:
    def removeElements(self, head: Optional[ListNode], val: int) -> Optional[ListNode]:
        #自己写一下不用虚拟头节点的情况
        #分两种情况：val在头节点和不在头节点
        while head != None and head.val == val: #头节点不为空且等于val
            head = head.next #将头节点往后移一位，想当于删除了
        if head == None:   #头节点为空的话说明空链表
            return None
        cur = head #用cur来遍历
        while cur.next != None: #头节点有值且下一个节点有值
            if cur.next.val == val:
                delNode = cur.next
                cur.next = delNode.next #删除
            else:
                cur = cur.next。#不删除的话就一直遍历
        return head

另外还有使用虚拟头节点删除的方法，这种方法不用讨论target是否在头节点这个情况了

# 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]:
        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设计链表

这道题好复杂，先把代码记录一下，以后慢慢看：

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


class MyLinkedList:

    def __init__(self):

        self.head = Node() #自定义一个空的头节点，方便后续操作
        self.size = 0 # 设置一个链表长度的属性，便于后续操作，注意每次增和删的时候都要更新


    def get(self, index: int) -> int: #得到链表中第几位的一个数
        if index < 0 or index >= self.size:  #先判断index是否超过范围
            return -1
        cur = self.head.next #从虚拟头节点之后的数开始遍历
        while(index):
            cur = cur.next
            index -= 1 #通过index向后遍历
        return cur.val


    def addAtHead(self, val: int) -> None:  #在头节点添加数
        new_node = Node(val)。#创建一个新节点
        new_node.next = self.head.next #下一位是真正的头节点
        self.head.next = new_node #把虚拟头节点连接上
        self.size += 1


    def addAtTail(self, val: int) -> None:  #在尾节点加数
        new_node = Node(val)
        cur = self.head
        while(cur.next): #从头开始遍历到尾，在尾加个节点
            cur = cur.next
        cur.next = new_node
        self.size += 1


    def addAtIndex(self, index: int, val: int) -> None: #在index处添加节点
        if index < 0:
            self.addAtHead(val)
            return
        elif index == self.size:
            self.addAtTail(val)
            return
        elif index > self.size:
            return
        
        node = Node(val)
        pre = self.head
        while(index):
            pre = pre.next
            index -= 1
        node.next = pre.next
        pre.next = node
        self.size += 1


    def deleteAtIndex(self, index: int) -> None:
        if index < 0 or index >= self.size:
            return
        pre = self.head
        while(index):
            pre = pre.next
            index -= 1
        pre.next = pre.next.next
        self.size -= 1

还有一种双链表的写法：

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


class MyLinkedList:

    def __init__(self):
        self._head, self._tail = Node(0), Node(0)  # 虚拟节点
        self._head.next, self._tail.prev = self._tail, self._head
        self._count = 0  # 添加的节点数

    def _get_node(self, index: int) -> Node:
        # 当index小于_count//2时, 使用_head查找更快, 反之_tail更快
        if index >= self._count // 2:
            # 使用prev往前找
            node = self._tail
            for _ in range(self._count - index):
                node = node.prev
        else:
            # 使用next往后找
            node = self._head   
            for _ in range(index + 1):
                node = node.next
        return node

    def get(self, index: int) -> int:
        """
        Get the value of the index-th node in the linked list. If the index is invalid, return -1.
        """
        if 0 <= index < self._count:
            node = self._get_node(index)
            return node.val
        else:
            return -1

    def addAtHead(self, val: int) -> None:
        """
        Add a node of value val before the first element of the linked list. After the insertion, the new node will be the first node of the linked list.
        """
        self._update(self._head, self._head.next, val)

    def addAtTail(self, val: int) -> None:
        """
        Append a node of value val to the last element of the linked list.
        """
        self._update(self._tail.prev, self._tail, val)

    def addAtIndex(self, index: int, val: int) -> None:
        """
        Add a node of value val before the index-th node in the linked list. If index equals to the length of linked list, the node will be appended to the end of linked list. If index is greater than the length, the node will not be inserted.
        """
        if index < 0:
            index = 0
        elif index > self._count:
            return
        node = self._get_node(index)
        self._update(node.prev, node, val)

    def _update(self, prev: Node, next: Node, val: int) -> None:
        """
            更新节点
            :param prev: 相对于更新的前一个节点
            :param next: 相对于更新的后一个节点
            :param val:  要添加的节点值
        """
        # 计数累加
        self._count += 1
        node = Node(val)
        prev.next, next.prev = node, node
        node.prev, node.next = prev, next

    def deleteAtIndex(self, index: int) -> None:
        """
        Delete the index-th node in the linked list, if the index is valid.
        """
        if 0 <= index < self._count:
            node = self._get_node(index)
            # 计数-1
            self._count -= 1
            node.prev.next, node.next.prev = node.next, node.prev

206反转链表

迭代法：

class Solution:
    def reverseList(self, head: ListNode) -> ListNode:
        cur = head   
        pre = None
        while(cur!=None):
            temp = cur.next # 保存一下 cur的下一个节点，因为接下来要改变cur->next
            cur.next = pre #反转
            #更新pre、cur指针
            pre = cur
            cur = temp
        return pre

递归法：

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

            return reverse(cur,tmp)
        
        return reverse(None,head)