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

最新推荐文章于 2024-08-30 15:57:36 发布

jjsherlock

最新推荐文章于 2024-08-30 15:57:36 发布

阅读量589

点赞数 9

分类专栏：算法 python 文章标签：算法链表数据结构

本文链接：https://blog.csdn.net/jjsherlock/article/details/139988424

版权

算法同时被 2 个专栏收录

4 篇文章 0 订阅

订阅专栏

python

4 篇文章 0 订阅

订阅专栏

什么是链表

链表是一种基本的数据结构，用于存储一系列元素，这些元素按顺序排列，但不需要占用连续的内存空间。链表中的每个元素称为节点（Node），每个节点包含两个部分：数据部分和指针部分。数据部分存储元素的值，而指针部分存储指向下一个节点的引用（或指针）。

链表的主要类型包括：

单链表（Singly Linked List）：每个节点包含一个数据字段和一个指向下一个节点的指针。最后一个节点的指针通常为空（None 或 null），表示链表的结束。
双链表（Doubly Linked List）：每个节点包含一个数据字段和两个指针，一个指向前一个节点，另一个指向后一个节点。这使得在双链表中可以双向遍历。
循环链表（Circular Linked List）：在单链表或双链表的基础上，将最后一个节点的指针指向第一个节点，形成一个循环。

链表的优点包括：

动态大小：链表的大小可以在运行时动态增加或减少，不需要预先分配固定大小的内存。
插入和删除操作高效：在链表中插入或删除节点通常只需要改变几个指针的指向，而不需要像数组那样移动大量元素。

链表的缺点包括：

访问元素不方便：链表不像数组那样可以通过索引直接访问元素，必须从头节点开始遍历链表，直到找到目标节点。
额外的内存开销：每个节点除了存储数据外，还需要存储指针信息，这会导致额外的内存开销。

链表在实现某些数据结构（如栈、队列、哈希表的链地址法解决冲突等）和解决某些算法问题时非常有用。然而，在需要频繁随机访问元素的场景中，数组或其他数据结构可能更为合适。

理解了以上的基础知识后，话不多说直接上题

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
输出：[]

这里就涉及如下链表操作的两种方式：

直接使用原来的链表来进行删除操作。
设置一个虚拟头结点在进行删除操作。

针对第一种方法，假如非头结点是对应值的话可以通过让前一个节点next指针直接指向下下一个节点就可以了，假如头结点是对应值该如何移除呢，其实只要将头结点向后移动一位就可以，这样就从链表中移除了一个头结点。这样写代码时候需要另写一段逻辑来处理移除头结点的情况。

那么可不可以以一种统一的逻辑来移除链表的节点呢。

其实可以设置一个虚拟头结点，这样原链表的所有节点就都可以按照统一的方式进行移除了。

203_链表删除元素6

这里来给链表添加一个虚拟头结点dummy_head为新的头结点，此时要移除这个旧头结点元素1。

这样是不是就可以使用和移除链表其他节点的方式统一了呢？

来看一下，如何移除元素1 呢，还是熟悉的方式,让next指正指向1的后面一个节点4。

最后呢在题目中，return 头结点的时候，别忘了 return dummy_head.next;，这才是新的头结点

# 定义一个单链表对象ListNode,val默认值为0  
# next是指向下一个 ListNode 对象的引用，默认值为 None，表示当前节点是链表的最后一个节点
# class ListNode(object):
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution(object):
    def removeElements(self, head, val):
        """
        :type head: ListNode
        :type val: int
        :rtype: ListNode
        """
        # 创建虚拟头部节点以简化删除过程
        dummy_head = ListNode(next = head)
        
        # 遍历列表并删除值为val的节点
        current = dummy_head
        while current.next:
            if current.next.val == val:
                current.next = current.next.next
            else:
                current = current.next
        
        return dummy_head.next

注：移除对应节点后，python的话不用手动管理内存，会自动清理内存

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
        self.next = next


class MyLinkedList(object):

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


    def get(self, index):
        """
        :type index: int
        :rtype: int
        """
        if index < 0 or index >= self.size:
            return -1
        #等于0时直接返回头结点
        current = self.dummy_head.next
        for i in range(index):
            current = current.next
        return current.val



    def addAtHead(self, val):
        """
        :type val: int
        :rtype: None
        """
        # 这里是一个关键点 得先让新插入的节点的next指向dummy_head.next,然后重新给dummy_head.next重新指向新加的节点
        self.dummy_head.next = ListNode(val, self.dummy_head.next)
        self.size += 1


    def addAtTail(self, val):
        """
        :type val: int
        :rtype: None
        """
        current = self.dummy_head
        for i in range(self.size):
            current = current.next
        current.next = ListNode(val)
        self.size += 1



    def addAtIndex(self, index, val):
        """
        :type index: int
        :type val: int
        :rtype: 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):
        """
        :type index: int
        :rtype: 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



# 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 ，请你反转链表，并返回反转后的链表。

示例 1：

输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]

示例 2：

输入：head = [1,2]
输出：[2,1]

示例 3：

输入：head = []
输出：[]

思路

翻转链表本质其实就是翻转2个节点之间的next指针的指向。例如原本a.next = b 变为b.next =a，链表长度为n,那么就翻转相邻节点的指针n次。那么原本头结点就会变成尾节点，而尾结点的next为None，故初始化的时候给pre（前一个节点）定义为None，也就是所谓的双指针法

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

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution(object):
    def reverseList(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        cur = head   
        pre = None
        while cur:
            temp = cur.next # 保存一下 cur的下一个节点，因为接下来要改变cur->next
            cur.next = pre #反转
            #更新pre、cur指针
            pre = cur
            cur = temp  
        return pre