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

今天主要学习链表的相关知识，链表是通过指针串联在一起的线性结构，节点由数据域和指向下一个节点的指针构成，其中最后一个节点的指针指向null
链表的种类主要有：单列表、双列表、循环列表。

链表定义

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

203. 移除链表元素
     通过设置虚拟头节点来执行删除操作

# 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_node = ListNode
        dummy_node.next = head
        cur_node = dummy_node

        while cur_node.next != None:
            if cur_node.next.val == val:
                cur_node.next = cur_node.next.next
            else:
                cur_node = cur_node.next

        return dummy_node.next

707. 设计链表
     单链表

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


class MyLinkedList:
# 要设置链表长度的属性
# head是虚拟头节点
    def __init__(self):
        self.head_node = listNode()
        self.list_len = 0

    def get(self, index: int) -> int:
        if index < 0 or index > self.list_len-1:
            return -1
        cur_node = self.head_node.next
        while index:
            cur_node = cur_node.next
            index -= 1
        return cur_node.val
    
    def addAtHead(self, val: int) -> None:
        new_head = listNode(val=val)
        new_head.next = self.head_node.next
        self.head_node.next = new_head
        self.list_len += 1

    def addAtTail(self, val: int) -> None:
        new_tail = listNode(val=val)
        cur_node = self.head_node
        while cur_node.next:
            cur_node = cur_node.next
        cur_node.next = new_tail
        self.list_len += 1

    def addAtIndex(self, index: int, val: int) -> None:
        if index < 0 or index > self.list_len:
            return
        elif index == self.list_len:
            self.addAtTail(val)
        else:
            cur_node = self.head_node
            for i in range(self.list_len):
                if i == index:
                    insert_head = listNode(val=val,next=cur_node.next)
                    cur_node.next = insert_head
                    self.list_len += 1
                    break
                else:
                    cur_node = cur_node.next
            
    def deleteAtIndex(self, index: int) -> None:
        if index < 0 or index > self.list_len-1:
            return
        else:
            cur_node = self.head_node
            for i in range(self.list_len):
                if i == index:
                    cur_node.next = cur_node.next.next
                    self.list_len -= 1
                    break
                else:
                    cur_node = cur_node.next

双链表（后续再补充）

206. 反转链表
     通过改变链表节点next指针的指向来对链表进行反转，采用双指针法，初始pre为null，cur指向头节点

# 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]:
        pre = None
        cur = head
        
        while cur != None:
            temp = cur.next
            cur.next = pre
            pre = cur
            cur = temp
            
        return pre
            

递归法（要专门练习一下）

# 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]:
        def reverse(pre,cur):
            if not cur:
                return pre
            
            tmp = cur.next
            cur.next = pre

            return reverse(cur,tmp)

        return reverse(None,head)