代码随想录算法训练营第三天| 链表01

一、链表基础

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

每一个节点由两部分组成，一个是数据域一个是指针域（存放指向下一个节点的指针）。

最后一个节点的指针域指向null（空指针的意思）。

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

链表类型：单链表、双链表、循环链表 

单链表： 

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

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

循环链表，就是链表首尾相连。

 

链表存储

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

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

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

链表定义

由于刷leetcode时，链表是定义好的，往往会忽略。

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

链表操作

增删节点都需要改变上一节点的next指针，特别注意，由于语言不同，内存回收机制不同，例如删除节点时，c++需要手动释放被删除节点内存，而java、python不需要 。

链表与数组对比 

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

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

二、力扣203.移除链表元素

题目链接：203. 移除链表元素 - 力扣（LeetCode）

讲解视频：手把手带你学会操作链表 | LeetCode：203.移除链表元素_哔哩哔哩_bilibili

文档讲解：代码随想录 (programmercarl.com)

题意：删除链表中等于给定值 val 的所有节点。

示例 1： 输入：head = [1,2,6,3,4,5,6], val = 6 输出：[1,2,3,4,5]

示例 2： 输入：head = [], val = 1 输出：[]

示例 3： 输入：head = [7,7,7,7], val = 7 输出：[]

思路

找到等于val的节点，想删除该节点 ，必须在前一个节点执行删除操作。

链表 1→2→3，要想删除 2，必须在节点 1 处操作，也就是把节点 1 的 next指针更新为节点 3。

假设等于val的节点是1（头结点），如何删除？

一种思路：需要另外写一段逻辑针对头结点删除，将头结点变为下一节点即可。

虚拟头结点思路：假设有一个虚拟头结点指向真实头结点，即使出现需要删除头结点的情况，也不需要另写多的逻辑。

# 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(next = head)
        cur = dummy_node
        while cur.next:
            if cur.next.val == val:
                cur.next = cur.next.next
            else:
                cur = cur.next
        return dummy_node.next 

三、力扣707.设计链表

题目链接：707. 设计链表 - 力扣（LeetCode）

题意：

在链表类中实现这些功能：

• get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。
• addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。
• addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。
• addAtIndex(index,val)：在链表中的第 index 个节点之前添加值为 val  的节点。如果 index 等于链表的长度，则该节点将附加到链表的末尾。如果 index 大于链表长度，则不会插入节点。如果index小于0，则在头部插入节点。
• deleteAtIndex(index)：如果索引 index 有效，则删除链表中的第 index 个节点。

思路：

学会运用虚拟头结点

视频讲解： 帮你把链表操作学个通透！LeetCode：707.设计链表_哔哩哔哩_bilibili

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

四、力扣206.反转链表

题目链接： 206. 反转链表 - 力扣（LeetCode）

题意：反转一个单链表。

示例: 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL

思路：

讲解视频：帮你拿下反转链表 | LeetCode：206.反转链表 | 双指针法 | 递归法_哔哩哔哩_bilibili

双指针法：

用双指针cur和pre，初始化cur = head, pre = null(因为反转后最开始的头结点会变成尾节点要指向null)。

进行循环，循环何时结束？当cur指针遍历到null时，null并不需要指向任何节点，此时为循环结束。即 while( cur != null)

用tmp暂存cur指向的节点，再进行反转。

最终cur指向null，pre指向新的头结点，所以最后返回pre。

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

递归法： 

理解透双指针解法，对递归法容易理解

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)