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

今日任务

• 链表理论基础
• 203.移除链表元素
• 707.设计链表
• 206.反转链表

链表理论基础 

文章链接： 代码随想录

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

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

链表的类型：

• 单链表：单链表中的指针域只能指向节点的下一个节点。
• 双链表：每一个节点有两个指针域，一个指向下一个节点，一个指向上一个节点；既可以向前查询也可以向后查询。
• 循环链表：链表首尾相连。可以用来解决约瑟夫环问题。

链表的存储方式：

• 链表中的节点在内存中不是连续分布的 ，而是散乱分布在内存中的某地址上，分配机制取决于操作系统的内存管理。
• 各个节点分布在内存的不同地址空间上，通过指针串联在一起。

链表节点定义：

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

链表的操作：

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

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

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

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

 

203.移除链表元素

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

给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == 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 输出：[]

 今日目标：虚拟头节点（dummy_head）的使用

class Solution:
    def removeElements(self, head: Optional[ListNode], val: int) -> Optional[ListNode]:
        dummy_head = ListNode(next = head)
        cur = dummy_head
        while cur.next != None:
            if cur.next.val == val:
                cur.next = cur.next.next
            else:
                cur = cur.next
        return dummy_head.next

 

707.设计链表

题目链接：力扣-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 的节点。

今日目标：链表综合操作，结合虚拟头结点；实现单链表的代码

单链表

# Single-linked list
class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

class MyLinkedList:

    def __init__(self):
        self.head = ListNode()
        self.size = 0

    def get(self, index: int) -> int:
        if index < 0 or index >= self.size:
            return -1
        cur = self.head.next
        while index:
            cur = cur.next
            index -= 1
        return cur.val

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

    def addAtTail(self, val: int) -> None:
        newNode = ListNode(val)
        cur = self.head
        while cur.next:
            cur = cur.next
        cur.next = newNode
        self.size += 1

    def addAtIndex(self, index: int, val: int) -> None:   
        if index < 0:
            self.addAtHead(val)
            return
        elif index == self.size:
            self.addAtTail(val)
            return
        elif index > self.size:
            return
        
        newNode = ListNode(val)
        pre = self.head
        while index:
            pre = pre.next
            index -= 1
        newNode.next = pre.next
        pre.next = newNode
        self.size += 1

    def deleteAtIndex(self, index: int) -> None:
        if index < 0 or index >= self.size:
            return
        pre = self.head
        while index:
            pre = pre.next
            index -= 1
        pre.next = pre.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.反转链表

题目链接：力扣-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: Optional[ListNode]) -> Optional[ListNode]:
        cur = head
        pre = None
        while cur:
            tmp = cur.next
            cur.next = pre
            pre = cur
            cur = tmp
        return pre