代码随想录算法训练营第三天 | Leetcode 203. 移除链表元素、707. 设计链表、206. 反转链表 | 单向链表的创建、删除、插入、查询、双指针&递归法-CSDN博客

本文链接：https://blog.csdn.net/odwsdt/article/details/133834358

题目：203. 移除链表元素

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

涉及数据结构

链表

我的思路

单向链表按值删除元素
但是定义不好更新过程，有点乱，看解析视频

解法

文档讲解：移除链表元素
视频讲解：移除链表元素

移除链表

移除操作，就是让节点 next 指针直接指向下下一个节点
因为单链表的特殊性，只能指向下一个节点，如果删除的是头结点:
- 直接使用原来的链表来进行删除操作
  - 头结点没有前一个节点 → 将头结点后移一位 head = head.next
- 设置一个虚拟头结点再进行删除操作【统一结点位置情况】
  - 给链表添加一个虚拟头结点为新的头结点
时间复杂度: $O (n)$
方法一：直接删除

# 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]:
        if head == None:
            return head
        # else:
            # p = head

        # 更新应该在if里 所以分两种
        # ① 一直遍历head
        while head != None and head.val == val:
            head = head.next

        # ② 更新非head节点，要一直判断p.next.val是否等于val，直到不等于，就更新p = p.next
        p = head
        while p != None and p.next != None:
            if p.next.val == val:
                p.next = p.next.next
            else:
                p = p.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]:
        if head == None:
            return head
        
        vir_head = ListNode(0,head) # 虚拟节点指向头结点

        p = vir_head
        while p != None and p.next != None:
            if p.next.val == val:
                p.next = p.next.next
            else:
                p = p.next
        return vir_head.next

效果、心得：

移除元素属于链表基本操作，要很熟练
个人理解：一般 p.next = p 是“指向” p ，p = p.next 是“更新” p

题目：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):
        self.val = val
        self.next = None

class MyLinkedList:

    def __init__(self):
        self.vit_head = ListNode(0) #虚拟节点
        self.size_ = 0

    def get(self, index: int) -> int:
        if index > self.size_ -1 or index < 0:
            return -1

        p = self.vit_head.next
        for _ in range(index):
            p = p.next
        return p.val


    def addAtHead(self, val: int) -> None:
        p = ListNode(val)
        p.next = self.vit_head.next
        self.vit_head.next = p
        #size要加1
        self.size_ += 1


    def addAtTail(self, val: int) -> None:
        p = self.vit_head
        while p.next:
            p = p.next
        tail = ListNode(val)
        p.next = tail
        self.size_ += 1


    def addAtIndex(self, index: int, val: int) -> None:
        if index < 0 or index > self.size_:
            return

        p = self.vit_head #与下标对应，p应该是index-1那个数
        for _ in range(index):
            p = p.next
        cur = ListNode(val)
        cur.next = p.next
        p.next = cur
        self.size_ += 1

    def deleteAtIndex(self, index: int) -> None:
        if index < 0 or index >= self.size_ :
            return

        p = self.vit_head
        for _ in range(index):
            p = p.next
        p.next = p.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)

双链表

待补充

效果、心得：

基本操作，要注意有虚拟节点和直接操作时的遍历边界，这个要细心分清楚

题目：206. 反转链表

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

涉及数据结构

单链表

我的思路

从前往后读成一个list，再用头插法创建链表

# 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]:
        if head == None or head.next == None:
            return head

        nums = []
        p = head
        while p:
            nums.append(p.val)
            p = p.next

        vir_head = ListNode(0) # 虚拟节点 方便头插

        for num in nums:
            node = ListNode(num)
            node.next = vir_head.next
            vir_head.next = node
        
        return vir_head.next

解法

文档讲解：反转链表
视频讲解：反转链表

思路

上面方法是对内存空间的浪费，只需要改变链表的 next 指针的指向，直接将链表反转，而不用重新定义一个新的链表
双指针法：
- cur, pre两个指针依次向后，cur指向pre
- 还需要临时指针保存未变向前 cur的下一个节点
- 先移动pre 后移动cur
递归法：
- 逻辑与双指针法一样
- 要注意停止条件
双指针法：时间复杂度: $O (n)$

# 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
        pre = None

        while cur:
            temp = cur.next
            cur.next = pre
            pre = cur
            cur = temp
        return pre

递归法：时间复杂度: $O (n)$

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def reverse(self, cur: ListNode, pre:ListNode) -> ListNode:
        if cur == None:
            return pre
        temp = cur.next
        cur.next = pre
        return self.reverse(temp, cur)


    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
        # cur = head
        # pre = None

        return self.reverse(head, None)