代码随想录算法训练营第三天| 203.移除链表元素、707.设计链表、206.反转链表

节点定义

一个节点由当前节点的值val和指向下一个节点的指针next组成。

# 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]:
        virtual_head = ListNode(next = head)
        current = virtual_head
        while current.next:
            if current.next.val == val:
                current.next = current.next.next
            else:
                current = current.next
        
        return virtual_head.next

设计链表

设计链表时注意index在尾节点时的判断

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

class MyLinkedList:

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

    def get(self, index: int) -> int:
        if index < 0 or self.size <= index:
            return -1

        current = self.virtual_head.next
        for i in range(index):
            current = current.next
        
        return current.val

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

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

    def addAtIndex(self, index: int, val: int) -> None:
        if index < 0 or self.size < index:
            return

        current = self.virtual_head
        for i in range(index):
            current = current.next
        current.next = ListNode(val, current.next)
        self.size += 1

    def deleteAtIndex(self, index: int) -> None:
        if index < 0 or self.size <= index:
            return
        
        current = self.virtual_head
        for i in range(index):
            current = current.next
        current.next = current.next.next
        self.size -= 1

反转链表

基本思路：将后一个节点的指针指向前一个即可

双指针法

class Solution:
    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
        left = None
        right = head
        while right:
            temp = right.next     #类似于a，b两值互换，需要一个临时变量temp
            right.next = left
            left = right
            right = temp
        
        return left    #返回原链表的尾节点

递归法

递归法有点意思，有时间再研究一下

class Solution:
    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
        return self.reverse(head, None)
    def reverse(self, right: Optional[ListNode], left: Optional[ListNode]) -> Optional[ListNode]:
        if right == None:
            return left
        temp = right.next
        right.next = left
        return self.reverse(temp, right)

参考文档：代码随想录