代码随想录算法训练营第三天|链表理论基础，203.移除链表元素，707.设计链表，206.反转链表-优快云博客

系列文章目录

代码随想录算法训练营第一天|数组理论基础，704. 二分查找，27. 移除元素
 代码随想录算法训练营第二天|977.有序数组的平方，209.长度最小的子数组，59.螺旋矩阵II

文章目录

系列文章目录
链表理论基础
203.移除链表元素
707.设计链表
206.反转链表

链表理论基础

（一）链表的概念

链表是一种通过指针串联在一起的线性结构：

每一个节点由两部分组成，一个是数据域一个是指针域（存放指向下一个节点的指针）；
最后一个节点的指针域指向null（空指针的意思）；
链表的入口节点称为链表的头结点也就是head。

（二）链表的类型

单链表
单链表中的指针域只能指向节点的下一个节点。
双链表

双链表的每一个节点有两个指针域，一个指向下一个节点，一个指向上一个节点；
双链表既可以向前查询也可以向后查询。

循环链表
循环链表是链表首尾相连，循环链表可以用来解决约瑟夫环问题。

（三）链表的存储方式

数组是在内存中是连续分布的，但是链表在内存中可不是连续分布的。
链表通过指针域的指针链接在内存中各个节点，所以链表中的节点在内存中不是连续分布的，而是散乱分布在内存中的某地址上，分配机制取决于操作系统的内存管理。

（四）链表的操作

删除节点
删除D节点只要将C节点的next指针指向E节点就可以了；在C++里最好是再手动释放这个D节点，释放这块内存；其他语言例如Java、Python等有自己的内存回收机制，不需要自己手动释放。
添加节点
链表的增添和删除都是O(1)操作，也不会影响到其他节点。但是要注意，要是删除第五个节点，需要从头节点查找到第四个节点通过next指针进行删除操作，查找的时间复杂度是O(n)。

（五）链表与数组

数组在定义的时候，长度是固定的，如果想改动数组的长度，需要重新定义一个新的数组；
链表的长度可以是不固定的，可以动态增删，适合数据量不固定、频繁增删、较少查询的场景。

203.移除链表元素

题目链接： 203.移除链表元素
题目内容： 给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回新的头节点。
视频讲解：手把手带你学会操作链表 | LeetCode：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]:
        #如果需要删除的是头节点
        while head is not None and head.val==val:
            head=head.next
        cur=head
        while cur is not None and cur.next is not None:
            if cur.next.val==val:
                cur.next=cur.next.next
            else:
                cur=cur.next
        return head

设置一个虚拟头节点：

# 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]:
        #设置一个虚拟头节点
        dummyhead=ListNode(next=head)
        cur=dummyhead
        while cur.next is not None:
            if cur.next.val==val:
                cur.next=cur.next.next
            else:
                cur=cur.next
        return dummyhead.next

707.设计链表

题目链接： 707.设计链表
题目内容： 你可以选择使用单链表或者双链表，设计并实现自己的链表。
视频讲解： 帮你把链表操作学个通透！LeetCode：707.设计链表

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

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-1:
            return -1
        #遍历至下标为index的节点
        cur=self.dummy_head.next
        while index:
            cur=cur.next
            index-=1
        return cur.val

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

    def addAtTail(self, val: int) -> None:
        cur=self.dummy_head
        #遍历至尾节点
        while cur.next is not None:
            cur=cur.next
        newnode=ListNode(val=val)
        cur.next=newnode
        self.size+=1

    def addAtIndex(self, index: int, val: int) -> None:
        if index<0 or index>self.size:
            return
        cur=self.dummy_head
        #遍历至下标为index的节点
        while index:
            cur=cur.next
            index-=1
        newnode=ListNode(val=val)
        newnode.next=cur.next
        cur.next=newnode
        self.size+=1

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



# Your MyLinkedList object will be instantiated and called as such:
# obj = MyLinkedList()
# param_1 = obj.get(index)
# obj.addAtHead(val)
# obj.addAtTail(val)
# obj.addAtIndex(index,val)
# obj.deleteAtIndex(index)

反思：这道题花了很久的时间，大体的答题思路在看完视频之后没有问题，但是细节方面存在错误，具体是在index合法性的判断上。

206.反转链表

题目链接： 707.设计链表
题目内容： 给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。
视频讲解： 帮你拿下反转链表 | LeetCode：206.反转链表 | 双指针法 | 递归法

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