DAY 3 链表-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_44959140/article/details/142236167

链表基础知识

什么是链表，链表是一种通过指针串联在一起的线性结构，每一个节点由两部分组成，一个是数据域一个是指针域（存放指向下一个节点的指针），最后一个节点的指针域指向null（空指针的意思）。

链表的入口节点称为链表的头结点也就是head。

如图所示：

链表1

链表的类型

接下来说一下链表的几种类型:

单链表

刚刚说的就是单链表。

双链表

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

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

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

如图所示：

链表2

循环链表

循环链表，顾名思义，就是链表首尾相连。

循环链表可以用来解决约瑟夫环问题。

链表4

链表的存储方式

了解完链表的类型，再来说一说链表在内存中的存储方式。

数组是在内存中是连续分布的，但是链表在内存中可不是连续分布的。

链表是通过指针域的指针链接在内存中各个节点。

所以链表中的节点在内存中不是连续分布的，而是散乱分布在内存中的某地址上，分配机制取决于操作系统的内存管理。

如图所示：

链表3

这个链表起始节点为2，终止节点为7，各个节点分布在内存的不同地址空间上，通过指针串联在一起。

链表的定义

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

链表的操作

删除节点

删除D节点，如图所示：

链表-删除节点

只要将C节点的next指针指向E节点就可以了。

D节点不是依然存留在内存里么？只不过是没有在这个链表里而已。

是这样的，所以在C++里最好是再手动释放这个D节点，释放这块内存。

其他语言例如Java、Python，就有自己的内存回收机制，就不用自己手动释放了。

添加节点

如图所示：

链表-添加节点

可以看出链表的增添和删除都是O(1)操作，也不会影响到其他节点。

但是要注意，要是删除第五个节点，需要从头节点查找到第四个节点通过next指针进行删除操作，查找的时间复杂度是O(n)。

性能分析

再把链表的特性和数组的特性进行一个对比，如图所示：

链表-链表与数据性能对比

数组在定义的时候，长度就是固定的，如果想改动数组的长度，就需要重新定义一个新的数组。

链表的长度可以是不固定的，并且可以动态增删，适合数据量不固定，频繁增删，较少查询的场景。

203. 移除链表元素

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

方法一：不用虚拟头节点

1. 多加一个判断头节点值是否为val的步骤

细节点：

用while持续判断
需要先判断头节点不为空：后续需要取head的值，不能操作空指针

2.正式循环要先判断cur是否为空

class Solution:
    def removeElements(self, head: Optional[ListNode], val: int) -> Optional[ListNode]:
        while head and head.val == val:
# 1、判断头节点不为空的必要性：因为要取head的值，操作空指针编译会报错。
# 2、不能用if，而要while：操作直到head值不为val
            head = head.next
        cur = head 
#虽然head的值不等于val，但是操作下一个节点需要上一个节点进行操作，所以cur从head开始
        while cur and cur.next: 
#cur有可能为空，空节点无next编译会报错
            if cur.next.val == val:# 比较的是cur.next的值
                cur.next = cur.next.next
            else:
                cur = cur.next
        return head

方法二：虚拟头节点

细节：return dummy.next。不能return head，有可能已经被删了，

class Solution:
    def removeElements(self, head: Optional[ListNode], val: int) -> Optional[ListNode]:    
        dummy = ListNode(next = head)
        cur = dummy
        while cur.next: #cur一定存在
            if cur.next.val == val:
                cur.next = cur.next.next
            else:
                cur = cur.next
        return dummy.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]:
        dummy = ListNode(next=head)
        pre = dummy
        cur = head 
        while cur:
            if cur.val == val:
                pre.next = cur.next
            else:
                pre = pre.next
            cur = cur.next
        return dummy.next

时间复杂度: O(n)
空间复杂度: O(1)

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 #节点的值，默认为 0。
        self.next = next
#指向下一个节点的指针，默认为 None，表示当前节点没有指向任何其他节点。
#不提供默认值，调用函数时必须提供这些参数，否则会报错。

class MyLinkedList:

    def __init__(self):
        self.dummy = ListNode()# 创建一个虚拟头节点
        self.size = 0 # 有效节点的计数，初始为 0

    def get(self, index: int) -> int: # 获取下标为index的节点的值
        if index < 0 or index >= self.size:
            return -1
        cur = self.dummy.next 
        for i in range(index):
# why index?举一个极端例子比如index = 0此时遍历0次获取头节点，那么应该是range(0)
            cur = cur.next
        return cur.val
            
    def addAtHead(self, val: int) -> None:# 头部插入节点
        self.dummy.next = ListNode(val, self.dummy.next) 
        # 先让新节点的next指向dummy.next,再让dummy.next指向新节点
        # 调换顺序会导致dummy.next已经变了，新节点的next指向dummy.next时会出错
        self.size+=1   

    def addAtTail(self, val: int) -> None: # 尾部插入节点
        cur = self.dummy #不能是cur.next 防止万一是空链表
        #for _ in range(self.size): #写一下size的写法，取极端值：size = 0，不用遍历直接插 此时应该是range(0)
        while cur.next:  #cur.next先遍历后 再判断 即已经等于none时才会退出循环
            cur = cur.next
        cur.next = ListNode(val,None) # 新节点的next是none
        self.size += 1

    def addAtIndex(self, index: int, val: int) -> None:# 在index下标位置插入节点
        if index<0 or index > self.size: # size=1 index最大为0
            return -1
        cur = self.dummy
        for _ in range(index):#使cur遍历到下标为index-1的位置 极端：index =0，不用遍历
            cur=cur.next 
        cur.next = ListNode(val, cur.next)
        self.size+=1

    def deleteAtIndex(self, index: int) -> None: # 删除下标为index的节点
        if index<0 or index>=self.size: # size = 1，index最大为0
            return -1
        cur = self.dummy
        for _ in range(index): #使cur遍历到下标为index-1的位置 极端：index =0，不用遍历
            cur = cur.next
        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 的相关操作为 O(index), 其余为 O(1)
空间复杂度: O(n)

206. 反转链表

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

pre从none开始，确保第一个节点即反转后的最后一个节点指向空
返回pre

class Solution:
    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
        pre, cur = None, head
        while cur:
            tmp = cur.next
            cur.next = pre
            pre = cur
            cur = tmp
        return pre

时间复杂度: O(n)
空间复杂度: O(1)