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

本文链接：https://blog.csdn.net/weixin_52142668/article/details/140208840

以下由代码随想录得到：

链表理论基础

链表是一种通过指针串联在一起的线性结构，每一个节点由两部分组成，一个是数据域，一个是指针域（存放指向下一个节点的指针），最后一个节点的指针域指向null。链表的入口节点称为链表的头节点也就是head。

链表的类型

1.单链表

如上

2.双链表

单链表的指针域只能指向节点的下一节点

双链表有两个指针域，一个指向上一节点，一个指向下一节点。

双链表既可以向前查询，也可以向后查询。

3.循环链表

循环链表就是首尾相连，循环列表可以解决约瑟夫环的问题。（约瑟夫环好像就是之前刷的那个每三人还是几人下船的问题）

那循环列表的最后一个节点的指针域指向第一个节点。

链表的存储方式

链表在内存中不是连续分布的，链表是通过指针域中的指针链接到在内存中的节点。所以链表中的节点在内存内不是连续分布的，而是散乱地分布在内存中的某地址上。

链表的定义方式

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

链表的操作

1.删除

链表的删除节点是将该节点的前一个节点的指针域中的指针直接指向该节点的下一个节点，而不是指向该节点。这个节点还存在在内存中，C++需要手动释放，但是想python、java有自己的内存回收机制，不用手动释放。

2.添加

链表的添加节点是将节点的前一个节点的指针域中的指针指向新节点，再将新节点的指针域中的指针指向该节点。

删除和添加都是复杂度为O(1)的操作，不会影响其他节点。

但是如果要删除最后一个节点，需要从头查询到倒数第二个节点，通过next操作删除最后一个节点，查找的时间复杂度为O(n)。

数组与链表的比较

	插入/删除的时间复杂度	查询的时间复杂度	适用场景
数组	O(n)	O(1)	数据量固定，频繁查询，较少增删
链表	O(1)	O(n)	数据量不固定，频繁增插，较少查询

203.移除链表元素

题目

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

尝试解答

不会～

代码随想录的代码

代码

版本一）虚拟头节点法
# 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)
        
        # 遍历列表并删除值为val的节点
        current = dummy_head
        while current.next:
            if current.next.val == val:
                current.next = current.next.next
            else:
                current = current.next
        
        return dummy_head.next

1.定义了一个链表节点类ListNode

2.创建了一个虚拟头节点dummy。它的下一个节点指向链表的头节点。这是为了处理头节点本身需要被删除的情况

3.使用current指针遍历链表。当current.next的值等于要删除的值val时，将current.next指向current.next.next，跳过这个节点。否则，移动current到下一个节点。

4.最后返回虚拟头节点的下一个节点dummy.next，即新的链表头。

学习

1.不明白为什么是current.next=current.next.next，而不是current=current.next.next

我觉得我应该是理解错current的意思了，我想的是current是当前节点指针域中的值，所以它指向下一个节点的位置，这样要是想删除目标节点，应该将该值改为下下个节点的位置，所以是 current=current.next.next。

而真正的是current代表当前节点，这个指针用来遍历链表中的每一个节点。在链表遍历过程中，我们使用current.next来访问当前节点的下一个节点。这样，我们可以通过修改current.next来跳过某些节点或将新节点插入到链表中。

指针本质上是一个变量，它存储了另一个变量或内存地址的地址。通过指针，可以直接访问和操作存储1在该内存地址上的数据

自己写

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution(object):
    def removeElements(self, head, val):
        #创建虚拟表头
        dummy=ListNode(next=head)
        current=dummy
        while current.next:
            if current.next.val==val:
                current.next=current.next.next
            else:
                current=current.next
        return dummy.next

707.设计链表

题目

你可以选择使用单链表或者双链表，设计并实现自己的链表。

单链表中的节点应该具备两个属性：val 和 next 。val 是当前节点的值，next 是指向下一个节点的指针/引用。

如果是双向链表，则还需要属性 prev 以指示链表中的上一个节点。假设链表中的所有节点下标从 0 开始。

实现 MyLinkedList 类：

MyLinkedList() 初始化 MyLinkedList 对象。
int get(int index) 获取链表中下标为 index 的节点的值。如果下标无效，则返回 -1 。
void addAtHead(int val) 将一个值为 val 的节点插入到链表中第一个元素之前。在插入完成后，新节点会成为链表的第一个节点。
void addAtTail(int val) 将一个值为 val 的节点追加到链表中作为链表的最后一个元素。
void addAtIndex(int index, int val) 将一个值为 val 的节点插入到链表中下标为 index 的节点之前。如果 index 等于链表的长度，那么该节点会被追加到链表的末尾。如果 index 比长度更大，该节点将 不会插入 到链表中。
void deleteAtIndex(int index) 如果下标有效，则删除链表中下标为 index 的节点。

代码随想录的代码

单链表法代码

版本一）单链表法
class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next
        
class MyLinkedList:
    def __init__(self):
        self.dummy_head = ListNode()
        self.size = 0

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

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

    def addAtTail(self, val: int) -> None:
        current = self.dummy_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 index > self.size:
            return
        
        current = self.dummy_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 index >= self.size:
            return
        
        current = self.dummy_head
        for i in range(index):
            current = current.next
        current.next = current.next.next
        self.size -= 1

学习

1.定义链表

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

2.创建虚拟头节点、初始化链表大小

def _init_(self)
    self.dummy_head=ListNode()
    self.size=0

3.返回索引节点值

def get（self，index）
    if index<0 or index >self.size:
        return -1
    current=self.dummy_head.next
    for i in range(index):
        current=current.next
    return current.val

4.插入一个新节点到表首

def addAtHead(self,val)
    self.dummy_head.next=ListNode(val,self.dummy_head.next)
    self.size+=1

5.插入一个新节点到表尾

def addAtTail(self, val)
    current=dummy_head
    while current.next:
        current=current.next
    current.next=ListNode(val)
    self.size+=1

5.插入特定位置

def addAtIndex(self, index)
    current=dummy_head
    if index<0 or index>self.size:
        return 
    for I in range(index):
        current=current.next
    current.next=ListNode(val, current.next)
    self.size+=1

6.删去特定位置

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

双链表法代码

版本二）双链表法
class ListNode:
    def __init__(self, val=0, prev=None, next=None):
        self.val = val
        self.prev = prev
        self.next = next

class MyLinkedList:
    def __init__(self):
        self.head = None
        self.tail = None
        self.size = 0

    def get(self, index: int) -> int:
        if index < 0 or index >= self.size:
            return -1
        
        if index < self.size // 2:
            current = self.head
            for i in range(index):
                current = current.next
        else:
            current = self.tail
            for i in range(self.size - index - 1):
                current = current.prev
                
        return current.val

    def addAtHead(self, val: int) -> None:
        new_node = ListNode(val, None, self.head)
        if self.head:
            self.head.prev = new_node
        else:
            self.tail = new_node
        self.head = new_node
        self.size += 1

    def addAtTail(self, val: int) -> None:
        new_node = ListNode(val, self.tail, None)
        if self.tail:
            self.tail.next = new_node
        else:
            self.head = new_node
        self.tail = new_node
        self.size += 1

    def addAtIndex(self, index: int, val: int) -> None:
        if index < 0 or index > self.size:
            return
        
        if index == 0:
            self.addAtHead(val)
        elif index == self.size:
            self.addAtTail(val)
        else:
            if index < self.size // 2:
                current = self.head
                for i in range(index - 1):
                    current = current.next
            else:
                current = self.tail
                for i in range(self.size - index):
                    current = current.prev
            new_node = ListNode(val, current, current.next)
            current.next.prev = new_node
            current.next = new_node
            self.size += 1

    def deleteAtIndex(self, index: int) -> None:
        if index < 0 or index >= self.size:
            return
        
        if index == 0:
            self.head = self.head.next
            if self.head:
                self.head.prev = None
            else:
                self.tail = None
        elif index == self.size - 1:
            self.tail = self.tail.prev
            if self.tail:
                self.tail.next = None
            else:
                self.head = None
        else:
            if index < self.size // 2:
                current = self.head
                for i in range(index):
                    current = current.next
            else:
                current = self.tail
                for i in range(self.size - index - 1):
                    current = current.prev
            current.prev.next = current.next
            current.next.prev = current.prev
        self.size -= 1

学习

1.双链表的定义

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

2.初始化双链表

def __init__(self):
    self.head=None
    self.tail=None
    self.size=0

3.返回索引节点值

def get(self,index):
    if index<0 or index>=self.size:
        return -1
    if index<self.size//2:
        current=self.head
        for I in range(index):
            =current.next
    else:
        current=self.tail
        for i in range(self.size-index-1):
            current=current.prev
    return current.val

4.插入到表首

def addAtHead(self):
#创建一个新节点，值为val，前一个节点为None，后一个节点为当前的head
    new_code=ListNode(val, None, self.head)
#如果当前链表的头部存在，则将其前一个节点指向新节点
    if self.head:
        self.head.prev=new_code
#如果链表为空，则新节点同时也是尾部的节点
    else:
        self.tail=new_code
#更新链表的头部为新节点
    self.head=new_code
    self.size+=1

注意new_node是一个包含val,prev,next属性的实例，是一个新节点。不要把它理解为是一个链表。

创建一个新节点后，现在代码里是有一个节点，一个链表。两个判断条件是将这两个组合在一起，最后一步是更新链表的头节点。

具体来说self.head.prev=new_node是将当前头节点的前指针指向新节点。换句话说，它修改的是当前头节点的prev属性，使其指向新节点，以建立双向链表的前向链接。而self.head=new_node是将链表的头指针更新为新节点，换句话说，它改变的是链表的头部引用，使其指向新创建的节点，具体来说，这行代码将self.head本身更新为new_node,这意味着新节点成为链表的第一个节点。

5.插入到表尾

def addAtTail(self,val):
    new_node=ListNode(val, self.tail, None)
    if self.tail:
        self.tail.next=new_node
    else:
        self.head=new_node
    self.tail=new_node
    self+=1

6.插入到特定位置

def addAtIndex(self,val,index):
    if index<0 or index>=self.size:
        return
    if index==0:
        self.addAtHead(val)
    elif index==self.size:
        self.addAtTail(val)
    else:
        if index<=self.size//2:
            current=self.head
            for i in range(index-1):
                current=current.next
        else:
            current=self.tail
            for i in range(self.size-index-1):
                current=current.prev
        new_node=ListNode(val,current,currnt.next)
        current.next.prev=new_node
        current.next=new_node
        self.size+=1

6.删除特定位置

def deleteAtIndex(self,val,index):
    if index=0 or index>=self.size:
        return
    elif index==0:
        self.head=self.head.next
        if self.head:
            self.head.prev=None
        else:
            self.tail=None
    elif index==self.size-1:
        self.tail=self.tail.prev
        if self.tail:
            self.tail.next=None
        else:
            self.head=None
    else:
        if index<self.size//2:
            current=self.head
            for I in range(index):
                current=current.next
            current.next=current.next.next
        else:
            current=self.tail
            for I in range(self.size-index-1)
                current=current.prev
            current.next.prev=current.prev
            current.prev.next=current.next
        self.size-=1

206.反转链表

题目

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

代码随想录的代码

双链表法

# 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: ListNode) -> ListNode:
        cur = head   
        pre = None
        while cur:
            temp = cur.next # 保存一下 cur的下一个节点，因为接下来要改变cur->next
            cur.next = pre #反转
            #更新pre、cur指针
            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: ListNode) -> ListNode:
        return self.reverse(head, None)
    def reverse(self, cur: ListNode, pre: ListNode) -> ListNode:
        if cur == None:
            return pre
        temp = cur.next
        cur.next = pre
        return self.reverse(temp, cur)

学习

对于递归法，它是按照双链表法写的。其中对于reverse函数，它的输入就是cur和pre。可以根据双链表法，它的初始化就是head和None。在内部，如果cur等于None意味着链表移动到最后，然后其余和双链表相同，最后再自己引用一下，此时cur和pre的值应该和双链表最后对应，即pre=cur，cur=temp