代码随想录算法训练营第三天 | 链表移除元素、设计链表、翻转链表

enzoherewj

已于 2023-08-11 05:10:27 修改

阅读量139

点赞数

分类专栏：代码随想录算法训练营文章标签：算法链表数据结构 leetcode python

于 2023-08-11 05:07:38 首次发布

本文链接：https://blog.csdn.net/enzoherewj/article/details/132220088

版权

代码随想录算法训练营专栏收录该内容

52 篇文章 3 订阅

订阅专栏

本文详细介绍了链表的概念、单链表和双链表的区别，展示了链表的存储方式、节点的增删操作，包括Python链表初始化方法。讨论了移除链表元素的两种策略，以及设计链表和翻转链表的复杂度分析，涉及递归和双指针方法。

摘要由CSDN通过智能技术生成

链表

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

单链表

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

单链表

双链表

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

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

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

双链表

链表的存储方式

链表在内存中不是连续的，各个节点分布在内存的不同地址空间上，通过指针串联在一起。

链表的增删

删除节点

添加节点

链表和数组的对比

链表的初始化（Python）

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

203. 移除链表元素

Leetcode

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

思路

例子如下：
在这里插入图片描述
但是这样的删除需要考虑一个问题，就是删除头节点需要多做一步操作。删除完头节点之后需要把head移动到下一个节点。

所以为了保证逻辑的统一我们采取虚拟头节点来进行删除元素：
在这里插入图片描述
这次删除头结点和删除其他节点时，操作的逻辑是一致的。

但是要注意我们在return的时候，记得要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]:
    	# 删除头节点，注意使用while loop
        while head and head.val == val:
            head = head.next
            
		# 删除非头节点
        cur = head
        while cur and cur.next:
            if cur.next.val == val:
                # delete cur.next
                cur.next = cur.next.next
            else:
                # cur pointer go to next node
                cur = cur.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]:
    	#创建虚拟头
        dummy = ListNode(next = head)
		
		#创建指针cur来遍历链表
        cur = dummy
        
        #此处思路和写法一的删除非头节点一致
        while cur.next:
            if cur.next.val == val:
                cur.next = cur.next.next
            else:
                cur = cur.next

        return dummy.next

复杂度分析

对以上两种写法来说，都是以下复杂度

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

707. 设计链表

Leetcode

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

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

思路

用虚拟头节点来操作会简单点。

代码

class ListNode:
	# 定义链表节点结构体
    def __init__(self, val = 0, next = None):
        self.val = val
        self.next = next

class MyLinkedList:
	#初始化链表，因为我们使用的是虚拟头节点来操作，所以我们会定义一个dummy虚拟头
	#定义size这样方便我们根据Index删除节点，或者在某个index增加节点
    def __init__(self):
        self.dummy = ListNode()
        self.size = 0

    def get(self, index: int) -> int:
        if index >= self.size or index < 0:
            return -1
        
        cur = self.dummy.next
        for i in range(index):
            cur = cur.next
        
        return cur.val

    def addAtHead(self, val: int) -> None:
        target = ListNode(val = val)

        temp = self.dummy.next
        self.dummy.next = target
        target.next = temp

        self.size += 1

    def addAtTail(self, val: int) -> None:
        cur = self.dummy

        #cur pointer travels to the tail
        while cur.next:
            cur = cur.next
        
        cur.next = ListNode(val = val)
        self.size += 1

    def addAtIndex(self, index: int, val: int) -> None:
        cur = self.dummy

        if index > self.size or index < 0:
            return
        
        for i in range(index):
            cur = cur.next

        cur.next = ListNode(val = val, next = cur.next)
        self.size += 1

    def deleteAtIndex(self, index: int) -> None:
        if index < 0 or index >= self.size:
            return
        
        cur = self.dummy
        for i in range(index):
            cur = cur.next
        
        cur.next = cur.next.next
        self.size -= 1

复杂度分析

时间复杂度：涉及index的相关操作为O(index), addAtTail是O(n). AddAtHead是O(1)
空间复杂度：O(1)

206. 翻转链表

Leetcode

反转一个单链表
示例: 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL

双指针

首先定义一个cur指针，指向头结点，再定义一个pre指针，初始化为null。

然后就要开始反转了，首先要把 cur.next节点用tmp指针保存一下，也就是保存一下这个节点。

为什么要保存一下这个节点呢，因为接下来要改变 cur.next 的指向了，将cur.next 指向pre ，此时已经反转了第一个节点了。

接下来，就是循环走如下代码逻辑了，继续移动pre和cur指针。

最后，cur指针已经指向了null，循环结束，链表也反转完毕了。此时我们return pre指针就可以了，pre指针就指向了新的头结点。

代码

# 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]:
        prev = None
        cur = head

        while cur:
        	#保存cur的下一个节点，因为接下来要改变cur.next
            temp = cur.next
            cur.next = prev #反转
            # 更新prev和cur指针
            prev = cur
            cur = temp
        
        return prev

复杂度分析

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

递归法

其实和双指针法是一样的逻辑，同样是当cur为空的时候循环结束，不断将cur指向pre的过程。

代码

# 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, prev = head, None
        return self.reverse(head, None)

    def reverse(self, cur, pre):
        if cur == None:
            return pre

        temp = cur.next
        cur.next = pre
        return self.reverse(temp, cur) #此处相当于双指针写法里面的 cur, pre = temp, cur

复杂度分析

时间复杂度：O(n)，要递归处理链表的每个节点
空间复杂度：O(n)，因为递归调用了 n 层栈空间

enzoherewj

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
代码随想录算法训练营第三天 | 链表移除元素、设计链表、翻转链表

什么是链表，链表是一种通过指针串联在一起的线性结构，每一个节点由两部分组成，一个是数据域一个是指针域（存放指向下一个节点的指针），最后一个节点的指针域指向null（空指针的意思）。但是这样的删除需要考虑一个问题，就是删除头节点需要多做一步操作。链表在内存中不是连续的，各个节点分布在内存的不同地址空间上，通过指针串联在一起。双链表：每一个节点有两个指针域，一个指向下一个节点，一个指向上一个节点。这次删除头结点和删除其他节点时，操作的逻辑是一致的。单链表中的指针域只能指向节点的下一个节点。
复制链接

扫一扫