Python蓝桥杯训练：基本数据结构 [链表]

最新推荐文章于 2024-03-06 10:32:08 发布
最新推荐文章于 2024-03-06 10:32:08 发布
阅读量853 收藏 2
点赞数 2
分类专栏： Python算法学习 蓝桥杯训练（Python） 文章标签： 链表 数据结构 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52417436/article/details/129008572
版权

Python蓝桥杯训练：基本数据结构 [链表]

文章目录

本次博客我是通过Notion软件写的，转md文件可能不太美观，大家可以去我的博客中查看：北天的 BLOG，持续更新中，另外这是我创建的编程学习小组频道，想一起学习的朋友可以一起！！！

一、链表理论基础知识

链表是一种特殊的数据结构，它是由节点（node）组成的。每个节点都存储了一个数据元素和一个指向下一个节点的指针。指向最后一个节点的指针是空的。因此，我们可以从第一个节点开始，通过沿着指针移动到下一个节点，直到到达最后一个节点为止。

链表有两种类型：单向链表和双向链表。在单向链表中，每个节点只指向下一个节点，而在双向链表中，每个节点都指向下一个节点和前一个节点。

链表具有动态内存分配，因此我们可以在不需要预先知道链表大小的情况下在链表中插入或删除元素。

在 Python 中，我们可以使用类来实现链表。每个节点可以是一个类的实例，其中包含数据元素和指向下一个节点的指针。

操作链表的常见任务包括插入节点、删除节点、查找节点、遍历链表等。

常用的链表操作有单链表、双向链表、循环链表、双向循环链表等。

下面我们来简单的介绍一下单链表、双向链表、循环链表、双向循环链表：

  • 单链表：在单链表中，每个节点只包含一个指向下一个节点的指针。指向最后一个节点的指针是空的。
  • 双向链表：在双向链表中，每个节点都包含一个指向下一个节点的指针和一个指向前一个节点的指针。
  • 循环链表：在循环链表中，最后一个节点的指针不是空的，而是指向第一个节点。因此，我们可以从任何节点开始，通过沿着指针移动到下一个节点，直到回到第一个节点为止。
  • 双向循环链表：双向循环链表是循环链表的双向版本，即每个节点都包含一个指向下一个节点的指针和一个指向前一个节点的指针，并且最后一个节点的指针指向第一个节点，第一个节点的指针指向最后一个节点。

二、有关链表的一些常见操作

  • 插入：在链表的任意位置插入新节点

    # 节点类
class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

# 链表类
class LinkedList:
    def __init__(self):
        self.head = None

    # 在指定位置插入一个新节点
    def insert_at_pos(self, pos, data):
        # 创建一个节点
        new_node = Node(data)
        # 如果链表为空
        if self.head is None:
            self.head = new_node
            return
        # 如果位置为0，则在开头插入
        if pos == 0:
            new_node.next = self.head
            self.head = new_node
            return
        # 遍历链表找到位置
        temp = self.head
        count = 0
        while temp is not None:
            if count == pos - 1:
                break
            temp = temp.next
            count += 1
        # 插入节点
        new_node.next = temp.next
        temp.next = new_node

  • 删除：从链表中删除指定的节点

    # 节点类
class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

# 链表类
class LinkedList:
    def __init__(self):
        self.head = None

    # 删除指定数据的节点
    def delete_node(self, data):
        # 如果链表为空
        if self.head is None:
            return
        # 如果头节点有数据
        if self.head.data == data:
            self.head = self.head.next
            return
        # 遍历链表
        temp = self.head
        while temp.next is not None:
            if temp.next.data == data:
                break
            temp = temp.next
        # 删除节点
        if temp.next is not None:
            temp.next = temp.next.next

  • 查询：查询链表中指定元素的位置

    # 节点类
class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

# 链表类
class LinkedList:
    def __init__(self):
        self.head = None

    # 找到指定数据的位置
    def find_pos(self, data):
        # 如果链表为空
        if self.head is None:
            return -1
        # 遍历链表
        temp = self.head
        count = 0
        while temp is not None:
						if temp.data == data:
								return count
						temp = temp.next
						count += 1
				# 元素未找到
				return -1

  • 修改：修改链表中指定元素的值

    
# 节点类
class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

# 链表类
class LinkedList:
    def __init__(self):
        self.head = None

		# 更新指定位置的节点
		def update_at_pos(self, pos, data):
		    # 如果链表为空
		    if self.head is None:
		        return
		    #遍历链表找到位置
		    temp = self.head
		    count = 0
		    while temp is not None:
		        if count == pos:
		            break
		        temp = temp.next
		        count += 1
		    #更新节点
		    if temp is not None:
		        temp.data = data

  • 遍历：从头到尾遍历整个链表

    # 节点类
class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

# 链表类
class LinkedList:
    def __init__(self):
        self.head = None

		# 遍历链表
		def traverse(self):
		    temp = self.head
		    while temp is not None:
		        print(temp.data)
		        temp = temp.next

  • 计数：计算链表中节点的数量

    # 节点类
class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

# 链表类
class LinkedList:
    def __init__(self):
        self.head = None

    # 统计链表中节点的个数
    def count_nodes(self):
        temp = self.head
        count = 0
        while temp is not None:
            count += 1
            temp = temp.next
        return count

  • 排序：对链表中的元素进行排序

    # 节点类
class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

# 链表类
class LinkedList:
    def __init__(self):
        self.head = None

    # 对链表进行排序
    def sort_linked_list(self):
        temp = self.head
        while temp is not None:
            current = temp
            while current.next is not None:
                if current.data > current.next.data:
                    current.data, current.next.data = current.next.data, current.data
                current = current.next
            temp = temp.next

  • 反转：将链表中的元素反转

    # 节点类
class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

# 链表类
class LinkedList:
    def __init__(self):
        self.head = None

    # 反转链表
    def reverse(self):
        prev = None
        current = self.head
        while current is not None:
            next = current.next
            current.next = prev
            prev = current
            current = next
        self.head = prev

三、力扣上面一些有关链表的题目练习

1、移除链表元素

示例1：

https://assets.leetcode.com/uploads/2021/03/06/removelinked-list.jpg

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

提示：

列表中的节点数目在范围 [0, 104] 内
1 <= Node.val <= 50
0 <= val <= 50

那么什么是虚拟节点呢？

虚拟节点（dummy node）是在链表头部创建一个不存储任何数据的特殊节点，用来解决链表操作问题。通常情况下，在链表头部插入或移除元素时，需要特殊处理，以避免对链表头部的直接操作。使用虚拟节点，可以在链表头部插入和移除元素时统一处理，从而简化代码。

# 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: ListNode, val: int) -> ListNode:
        dummy = ListNode(0)
        dummy.next = head
        prev = dummy
        current = head
        while current:
            if current.val == val:
                prev.next = current.next
            else:
                prev = current
            current = current.next
        return dummy.next

上述代码的具体实现思路如下：

  1. 创建一个虚拟节点，该节点的值不重要，只是用来作为链表的头部。
  2. 创建两个指针，一个指向虚拟节点（prev），一个指向链表头（current）。
  3. 在链表中遍历每一个节点，如果该节点的值等于给定值val，则将prev的next指向该节点的下一个节点，即跳过该节点。如果该节点的值不等于给定值val，则将prev指向该节点。
  4. 遍历完整个链表后，返回虚拟节点的next。
  1. 链表的遍历顺序：确保指针正确的遍历链表的每一个节点。
  2. 变量的更新：确保在遍历每一个节点时，更新prev和current的值。
  3. 虚拟节点的初始化：创建一个虚拟节点并且初始化它的next值为链表头。
  4. 返回值：确保返回虚拟节点的next，而不是链表头。

如何要对上述代码进行示例测试的话，需要注意这跟之前的数组不一样，具体例子如下：

head = ListNode(1)
head.next = ListNode(2)
head.next.next = ListNode(6)
head.next.next.next = ListNode(3)
head.next.next.next.next = ListNode(4)
head.next.next.next.next.next = ListNode(5)
head.next.next.next.next.next.next = ListNode(6)
a = Solution()
result = a.removeElements(head, 6)
node = result
while node:
    print(node.val, end=" ")
    node = node.next

B站上面卡尔老师对于这道题的思路讲得很不错，在这里推荐大家去看看他的教学视频：

https://www.bilibili.com/video/BV18B4y1s7R9/?spm_id_from=333.788&vd_source=eae0406d86828f39f6ac3a3b0e8a2a34

2、设计链表

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

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

示例：

MyLinkedList linkedList = new MyLinkedList();
linkedList.addAtHead(1);
linkedList.addAtTail(3);
linkedList.addAtIndex(1,2);   //链表变为1-> 2-> 3
linkedList.get(1);            //返回2
linkedList.deleteAtIndex(1);  //现在链表是1-> 3
linkedList.get(1);            //返回3

提示：

0 <= index, val <= 1000
请不要使用内置的 LinkedList 库。
get, addAtHead, addAtTail, addAtIndex 和 deleteAtIndex 的操作次数不超过 2000。

其中get(index)实现思路是：

  1. 先判断给定的索引index是否合法，即是否小于0或大于链表的长度，如果不合法返回-1。
  2. 定义一个当前节点cur，并将其设为头节点的下一个节点（即链表的第一个节点）。
  3. 进入循环，当index不为0时，cur更新为其下一个节点，index减1。
  4. 当循环结束后，cur的val属性即为所需要的值，返回该值。

其中addAtHead(val)实现思路是：

  1. 创建新节点并设置其值。
  2. 将新节点的next指针指向当前的链表头部。
  3. 将新节点设为链表头部。
  4. 更新链表的大小。

其中addAtTail(val)实现思路是：

  1. 创建新节点并设置其值。
  2. 创建当前指针，从链表头开始循环，直到找到链表的末尾。
  3. 将新节点添加到末尾。
  4. 更新链表的大小。

其中addAtIndex实现思路是：

  1. 检查给定索引是否小于0或大于链表的大小，如果是，返回-1。
  2. 创建新节点并设置其值。
  3. 创建当前指针，从链表头开始循环，直到找到给定索引处的节点的前一个节点。
  4. 将新节点的next指针指向给定索引处的节点。
  5. 将前一个节点的next指针指向新节点。
  6. 更新链表的大小。

其中deleteAtIndex(index)实现思路是：

  1. 检查给定索引是否小于0或大于等于链表的大小，如果是，则返回。
  2. 否则，创建一个当前指针，并从链表头开始循环，直到找到给定索引前一个节点。
  3. 删除该节点并更新链表的大小。
class Node(object):
    def __init__(self, x=0):
        self.val = x
        self.next = None

class MyLinkedList(object):

    def __init__(self):
        self.head = Node()
        self.size = 0 # 设置一个链表长度的属性，便于后续操作，注意每次增和删的时候都要更新

    def get(self, index):
        """
        :type index: int
        :rtype: 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):
        """
        :type val: int
        :rtype: None
        """
        new_node = Node(val)
        new_node.next = self.head.next
        self.head.next = new_node
        self.size += 1

    def addAtTail(self, val):
        """
        :type val: int
        :rtype: None
        """
        new_node = Node(val)
        cur = self.head
        while(cur.next):
            cur = cur.next
        cur.next = new_node
        self.size += 1

    def addAtIndex(self, index, val):
        """
        :type index: int
        :type val: int
        :rtype: None
        """
        if index < 0:
            self.addAtHead(val)
            return
        elif index == self.size:
            self.addAtTail(val)
            return
        elif index > self.size:
            return

        node = Node(val)
        pre = self.head
        while(index):
            pre = pre.next
            index -= 1
        node.next = pre.next
        pre.next = node
        self.size += 1

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

# 双链表
# 相对于单链表, Node新增了prev属性
class Node:
    
    def __init__(self, val):
        # 存储节点的值
        self.val = val
        # 指向前一个节点
        self.prev = None
        # 指向下一个节点
        self.next = None

# 双链表的实现
class MyLinkedList:

    def __init__(self):
        # 虚拟节点，存储的值可以是0或者任意值
        self._head, self._tail = Node(0), Node(0)  
        # 虚拟节点的前一个节点和后一个节点都是自己
        self._head.next, self._tail.prev = self._tail, self._head
        # 添加的节点数
        self._count = 0  

    def _get_node(self, index: int) -> Node:
        # 当index小于_count//2时, 使用_head查找更快, 反之_tail更快
        if index >= self._count // 2:
            # 使用prev往前找
            node = self._tail
            for _ in range(self._count - index):
                node = node.prev
        else:
            # 使用next往后找
            node = self._head   
            for _ in range(index + 1):
                node = node.next
        # 返回找到的节点
        return node

    def get(self, index: int) -> int:
        """
        获取链表中第 index 个节点的值。
        如果索引无效，则返回 -1。
        """
        # 如果index是合法的，即在0和_count-1的范围内
        if 0 <= index < self._count:
            # 找到对应的节点
            node = self._get_node(index)
            # 返回该节点的值
            return node.val
        else:
            # 如果index不合法，返回-1
            return -1

    def addAtHead(self, val: int) -> None:
    """
    在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。
    """
    # 调用_update方法，并传入链表的头节点，头节点的下一个节点，以及要插入的值val
    self._update(self._head, self._head.next, val)

		def addAtTail(self, val: int) -> None:
		    """
		    将值为 val 的节点附加到链表的最后一个元素。
		    """
		    # 调用_update方法，并传入链表的尾节点的前一个节点，尾节点，以及要插入的值val
		    self._update(self._tail.prev, self._tail, val)
		
		def addAtIndex(self, index: int, val: int) -> None:
		    """
		    在链表的第 index 个节点之前添加一个值为 val 的节点。如果索引等于链表的长度，则该节点将追加到链表的末尾。如果索引大于长度，则不会插入该节点。
		    """
		    # 如果索引小于0，则将索引设置为0；如果索引大于链表长度，则直接返回
		    if index < 0:
		        index = 0
		    elif index > self._count:
		        return
		    # 获取索引对应的节点
		    node = self._get_node(index)
		    # 调用_update方法，并传入该节点的前一个节点，该节点，以及要插入的值val
		    self._update(node.prev, node, val)
		
		def _update(self, prev: Node, next: Node, val: int) -> None:
		    """
		    更新节点
		    :param prev: 相对于更新的前一个节点
		    :param next: 相对于更新的后一个节点
		    :param val:  要添加的节点值
		    """
		    # 计数累加
		    self._count += 1
		    # 创建一个新节点
				node = Node(val)
				# 设置前后节点的指向
				prev.next, next.prev = node, node
				node.prev, node.next = prev, next
		
		def deleteAtIndex(self, index: int) -> None:
				"""
				如果索引有效，则删除链表中的第 index 个节点。
				"""
				# 如果 index 有效
				if 0 <= index < self._count:
						# 获取 index 节点
						node = self._get_node(index)
						# 计数-1
						self._count -= 1
						# 将前后节点的指向跳过该节点
						node.prev.next, node.next.prev = node.next, node.prev

B站上面卡尔老师对于这道题的思路讲得很不错，在这里推荐大家去看看他的教学视频：

https://www.bilibili.com/video/BV1FU4y1X7WD/?spm_id_from=333.788&vd_source=eae0406d86828f39f6ac3a3b0e8a2a34

3、反转链表

示例 1：

https://assets.leetcode.com/uploads/2021/02/19/rev1ex1.jpg

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

示例 2:

https://assets.leetcode.com/uploads/2021/02/19/rev1ex2.jpg

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

示例 3：

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

提示：

链表中节点的数目范围是 [0, 5000]
-5000 <= Node.val <= 5000
  1. 使用递归的方法，从链表的最后一个节点开始递归，每次递归都把当前节点的 next 指向前一个节点，最后返回新的头节点。
  2. 使用循环的方法，通过循环，每次取出当前节点，并把当前节点的 next 指向前一个节点，最后把头节点指向最后一个节点。

递归的代码实现会非常的简洁，但是有时候会很难理解每一步的含义，所以我们可以先尝试使用第二种循环的方法，也就是使用双指针的方法反转链表。

  1. 创建两个指针 pre 和 cur，pre 指向当前节点的前一个节点，cur 指向当前节点。
  2. 使用 cur.next 来移动 cur，同时使用 pre 和 cur 实现反转。
  3. 在每一轮循环中，cur 移动到下一个节点，pre 指向当前节点，cur.next 指向 pre。
  4. 循环结束后，链表的头和尾已经反转。
  5. 返回新的链表头，即原来的链表尾。
# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def reverseList(self, head: ListNode) -> ListNode:
        prev = None
        curr = head
        while curr:
            next_node = curr.next
            curr.next = prev
            prev = curr
            curr = next_node
        return prev

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def reverseList(self, head: ListNode) -> ListNode:
        # 终止条件：当前节点为空或当前节点的下一个节点为空
        if not head or not head.next:
            return head
        
        # 先递归到最后一个节点，让最后一个节点的下一个节点指向前一个节点
        new_head = self.reverseList(head.next)
        head.next.next = head
        head.next = None

        # 返回新的头节点
        return new_head

我们还可以在原函数reverseList里面自己定义一个反转函数实现反转操作，具体实现过程如下：

# 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: ListNode) -> ListNode:
        """
        反转单链表
        :param head: 链表的头节点
        :return: 反轮后的链表头节点
        """
        def reverse(pre, cur):
            """
            递归函数，每次传入前一个节点和当前节点，反转链表
            :param pre: 前一个节点
            :param cur: 当前节点
            :return: 反转后的链表头节点
            """
            if not cur:
                # 当前节点为空，说明已经到达末尾，返回前一个节点
                return pre
            # 保存当前节点的下一个节点
            tmp = cur.next
            # 反转链表，当前节点的下一个节点指向前一个节点
            cur.next = pre
            # 递归下一个节点
            return reverse(cur, tmp)
        # 从head开始，pre为None
        return reverse(None, head)

B站上面卡尔老师对于这道题的思路讲得很不错，在这里推荐大家去看看他的教学视频：

https://www.bilibili.com/video/BV1nB4y1i7eL/?spm_id_from=333.788&vd_source=eae0406d86828f39f6ac3a3b0e8a2a34

4、两两交换链表中的节点

示例1：

https://assets.leetcode.com/uploads/2020/10/03/swap_ex1.jpg

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

示例2：

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

示例3：

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

提示：

链表中节点的数目在范围 [0, 100] 内
0 <= Node.val <= 100
  • 递归实现：通过递归的方式对链表进行交换，并在递归过程中更新节点的指向。
  • 迭代实现：通过迭代的方式对链表进行交换，通过不断更新节点的指向实现交换。

和上面的反转链表题目操作类似，我们还是先使用双指针迭代实现，然后再用递归的方法实现。

  1. 定义一个虚拟节点dummy，其next指向head。
  2. 定义一个指针pre指向dummy，表示要交换的前一个节点。
  3. 循环条件为pre的next指向的节点不为空且该节点的下一个节点也不为空。
  4. 定义指针cur指向pre的next指向的节点，定义指针post指向cur的next指向的节点。
  5. 交换cur和post两个节点：cur的next指向post的next指向的节点，post的next指向cur。
  6. 将pre的next指向post。
  7. 将pre指向pre的next指向的节点的next指向的节点。
  8. 返回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 swapPairs(self, head: ListNode) -> ListNode:
        # 定义虚拟节点dummy
        dummy = ListNode(0)
        dummy.next = head
        pre = dummy
        while pre.next and pre.next.next:
            cur = pre.next
            post = cur.next
            cur.next = post.next
            post.next = cur
            pre.next = post
            pre = pre.next.next
        return dummy.next

使用虚拟节点递归实现的思路：

  1. 定义虚拟节点dummy，并将其next指向头节点。
  2. 如果链表不为空，则从头节点开始递归，每次递归都会交换当前节点与其后面的节点。
  3. 对于每次递归，通过将当前节点的next指向其后面的节点的next指针，并递归当前节点的next指针，实现链表节点的交换。
  4. 递归边界为当前节点的next指针为None或只有一个节点时。
  5. 完成递归后，返回头节点即可。

具体递归代码实现如下：

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def swapPairs(self, head: ListNode) -> ListNode:
        # 定义虚拟节点dummy
        dummy = ListNode(0)
        dummy.next = head
        if head and head.next:
            next_node = head.next.next
            head.next.next = head
            head.next = self.swapPairs(next_node)
            dummy.next = head.next
        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 swapPairs(self, head: ListNode) -> ListNode:
        # 定义虚拟节点dummy
        dummy = ListNode(0)
        dummy.next = head
        if head and head.next:
            head.next, dummy.next.next, dummy.next = self.swapPairs(head.next.next), head, head.next
        return dummy.next

B站上面卡尔老师对于这道题的思路讲得很不错，在这里推荐大家去看看他的教学视频：

https://www.bilibili.com/video/BV1YT411g7br/?spm_id_from=333.788&vd_source=eae0406d86828f39f6ac3a3b0e8a2a34

5、删除链表的倒数第N个节点

示例1：

https://assets.leetcode.com/uploads/2020/10/03/remove_ex1.jpg

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

示例2：

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

示例3：

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

提示：

链表中结点的数目为 sz
1 <= sz <= 30
0 <= Node.val <= 100
1 <= n <= sz
  1. 定义虚拟节点dummy，把dummy的next指向head，并定义快指针fast和慢指针slow，都指向dummy。
  2. 先将快指针移动n+1步，使其到达链表的结尾或倒数第n个位置。
  3. 然后同时移动快指针和慢指针，直到快指针到达链表的末尾。
  4. 最后把慢指针的下一个节点删除。
  5. 返回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 removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:
        dummy = ListNode(0)
        dummy.next = head
        slow = dummy
        fast = dummy
        for i in range(n + 1):
            fast = fast.next
        while fast:
            slow = slow.next
            fast = fast.next
        slow.next = slow.next.next
        return dummy.next

我们还可以换一种写法来实现：

首先，我们新增一个虚拟节点 dummy，它的下一个节点是原链表的头节点 head。然后，我们定义两个指针 slow 和 fast，它们都从 dummy 出发，最开始 fast 指针先往前走 n 步。接着，两个指针同时向前走，当 fast 指针到达结尾后，slow 的下一个节点就是倒数第 N 个节点。最后，我们直接删除该节点，然后返回 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 removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:
        dummy = ListNode()
        dummy.next = head

        slow, fast = dummy, dummy
        while(n!=0): #fast先往前走n步
            fast = fast.next
            n -= 1
        while(fast.next!=None):
            slow = slow.next
            fast = fast.next
        #fast 走到结尾后，slow的下一个节点为倒数第N个节点
        slow.next = slow.next.next #删除
        return dummy.next

B站上面卡尔老师对于这道题的思路讲得很不错，在这里推荐大家去看看他的教学视频：

https://www.bilibili.com/video/BV1vW4y1U7Gf/?spm_id_from=333.788

6、相交链表

图示两个链表在节点 c1 开始相交：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SzDLGQGH-1676269812178)(https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2018/12/14/160_statement.png)]

题目数据 保证 整个链式结构中不存在环。

注意，函数返回结果后，链表必须 保持其原始结构 。

自定义评测：

评测系统 的输入如下（你设计的程序 不适用 此输入）：

intersectVal - 相交的起始节点的值。如果不存在相交节点，这一值为 0
listA - 第一个链表
listB - 第二个链表
skipA - 在 listA 中（从头节点开始）跳到交叉节点的节点数
skipB - 在 listB 中（从头节点开始）跳到交叉节点的节点数

评测系统将根据这些输入创建链式数据结构，并将两个头节点 headA 和 headB 传递给你的程序。如果程序能够正确返回相交节点，那么你的解决方案将被 视作正确答案 。

示例1：

https://assets.leetcode.com/uploads/2021/03/05/160_example_1_1.png

输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,6,1,8,4,5], skipA = 2, skipB = 3
输出：Intersected at '8'
解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,6,1,8,4,5]。
在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。
— 请注意相交节点的值不为 1，因为在链表 A 和链表 B 之中值为 1 的节点 (A 中第二个节点和 B 中第三个节点) 是不同的节点。换句话说，它们在内存中指向两个不同的位置，而链表 A 和链表 B 中值为 8 的节点 (A 中第三个节点，B 中第四个节点) 在内存中指向相同的位置。

示例2：

https://assets.leetcode.com/uploads/2021/03/05/160_example_2.png

输入：intersectVal = 2, listA = [1,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
输出：Intersected at '2'
解释：相交节点的值为 2 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [1,9,1,2,4]，链表 B 为 [3,2,4]。
在 A 中，相交节点前有 3 个节点；在 B 中，相交节点前有 1 个节点。

示例3：

https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2018/12/14/160_example_3.png

输入：intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
输出：null
解释：从各自的表头开始算起，链表 A 为 [2,6,4]，链表 B 为 [1,5]。
由于这两个链表不相交，所以 intersectVal 必须为 0，而 skipA 和 skipB 可以是任意值。
这两个链表不相交，因此返回 null 。

提示：

listA 中节点数目为 m
listB 中节点数目为 n
1 <= m, n <= 3 * 104
1 <= Node.val <= 105
0 <= skipA <= m
0 <= skipB <= n
如果 listA 和 listB 没有交点，intersectVal 为 0
如果 listA 和 listB 有交点，intersectVal == listA[skipA] == listB[skipB]

进阶：你能否设计一个时间复杂度 O(m + n)、仅用 O(1)内存的解决方案？

  1. 创建两个指针pA和pB，分别指向两个链表的头结点headA和headB。

  2. 先判断两个链表是否存在交点：

    a. 如果pA == pB，则返回pA，说明此时两个指针所指向的结点就是交点。

    b. 如果pA != pB，则继续遍历：

    i. 若pA存在，则将pA移动到pA.next，否则将pA指向headB；

    ii. 若pB存在，则将pB移动到pB.next，否则将pB指向headA。

  3. 循环2的步骤，直到pA == pB或pA和pB均不存在，此时说明两个链表没有交点或已经找到了交点。

知道了具体实现思路，那么写出代码也就不是很难了，具体代码实现是：

# Definition for singly-linked list.
class ListNode:
    def __init__(self, x):
        self.val = x
        self.next = None

class Solution:
    def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
        pA = headA
        pB = headB
        while pA != pB:
            pA = pA.next if pA else headB
            pB = pB.next if pB else headA
        return pA

我们使用的这种方法的优点在于，不论两个链表的长度是否相等，最多只需要遍历两次链表，时间复杂度为O(m + n)，其中m和n分别是两个链表的长度。

7、环形链表Ⅱ

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

不允许修改 链表。

示例1：

https://assets.leetcode.com/uploads/2018/12/07/circularlinkedlist.png

输入：head = [3,2,0,-4], pos = 1
输出：返回索引为 1 的链表节点
解释：链表中有一个环，其尾部连接到第二个节点。

示例2：

https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2018/12/07/circularlinkedlist_test2.png

输入：head = [1,2], pos = 0
输出：返回索引为 0 的链表节点
解释：链表中有一个环，其尾部连接到第一个节点。

示例3：

https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2018/12/07/circularlinkedlist_test3.png

输入：head = [1], pos = -1
输出：返回 null
解释：链表中没有环。

提示：

链表中节点的数目范围在范围 [0, 104] 内
-105 <= Node.val <= 105
pos 的值为 -1 或者链表中的一个有效索引

进阶：你是否可以使用 O(1)空间解决此题？

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def detectCycle(self, head: ListNode) -> ListNode:
        fast = slow = head
        while fast and fast.next:
            fast = fast.next.next
            slow = slow.next
            if fast == slow:
                slow = head
                while slow != fast:
                    slow = slow.next
                    fast = fast.next
                return slow
        return None

上述算法的实现步骤为：

  1. 创建两个指针fast和slow，分别指向head。
  2. 每次将fast移动到fast.next.next，将slow移动到slow.next。
  3. 如果fast == slow，说明链表存在环。此时，将slow指向head，同时保持fast不变，再次每次将slow移动到slow.next，将fast移动到fast.next。如果在某一时刻slow == fast，则说明slow和fast所指向的结点即为环的入口。
  4. 如果fast不存在或fast.next不存在，则说明链表不存在环，返回None。

B站上面卡尔老师对于这道题的思路讲得很不错，在这里推荐大家去看看他的教学视频：

https://www.bilibili.com/video/BV1if4y1d7ob/?spm_id_from=333.1007.top_right_bar_window_history.content.click&vd_source=eae0406d86828f39f6ac3a3b0e8a2a34

-北天-
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
7.1.1 蓝桥杯基础数据结构之链表、栈、队列
tang7mj的博客
01-29 341
在蓝桥杯等程序设计竞赛中，掌握基础数据结构对于编写高效、可靠的代码至关重要。本文将探讨如何使用数组来实现三种基础数据结构：链表、栈和队列，并提供相应的C++代码示例。
【蓝桥杯-筑基篇】数据结构基础
Javascript_tsj的博客
04-02 1329
在 HashMap 中，键是唯一的，值可以重复。LinkedList类还提供了一些其他的方法，例如getFirst()、getLast()、removeFirst()和removeLast()等，可以根据实际需求选择使用。TreeSet 是 Java 中的一个集合类，它实现了 SortedSet 接口，可以存储元素，并按照元素的自然顺序或指定的比较器顺序进行排序。LinkedList类是线程不安全的，如果需要在多线程环境下使用，可以使用并发包中的ConcurrentLinkedDeque类。
【蓝桥杯冲击国赛计划第2天】双向链表、循环链表 {题目：小王子链表、约瑟夫环}
命运的左轮的博客
11-10 442
了解双向链表和循环链表的定义和使用。
力扣刷题记录---利用python实现链表的基本操作
打工人。。
07-29 342
如何使用python实现链表的基本操作，包括结点的定义，链表的定义，求链表长度，链表是否为空等等一系列函数提示：以下是本篇文章正文内容，下面案例可供参考由于python万物皆对象，变量实际上是对象的引用，相当于就保存了对象的地址初始化时会自动生成一个空链表，其中head指向None。
Python蓝桥杯训练：基本数据结构 [哈希表]
北天的博客
02-26 1277
Python蓝桥杯训练哈希表篇，本期博客内容比较多，干货也比较多，在代码随想录的刷题思路基础上加入了自己的很多思路，供大家学习！
Leetcode题目：python 实现链表题目合集(边做边更新)
weixin_43585712的博客
04-22 807
思路及注意点（新手走的弯路）： 1.一定要明确l1,l2链表是不可以在尾部加新节点的，因为最后一个指针值为None。 2.保存结果的链表必须满足在尾部添加节点，因为进位的时候要加1，利用ListNode()可以完成动态添加节点。 3.遍历2个链表，先走完的默认值为0，当另一个也走完的时候，一定要注意不要再加新节点了，此可结果链表的长度等于l1，l2中最长的那个。 4.遍历完后，判断是否需要进位，进位则加一个新节点，并赋值为1。 下面的程序是调试的所有代码。 "=====================..
Python蓝桥杯备战资料（数据结构+真题解析+模拟题）.rar
02-19
这份资源提供了全面的Python蓝桥杯备战资料，涵盖了数据结构知识、历年真题解析以及模拟题训练。内容包括数据结构基础、真题解析案例、模拟题训练等，旨在帮助读者全面备战蓝桥杯。 适用人群： 准备参加Python...
资源蓝桥杯VIP真题以及数据结构训练资料
11-14
"资源蓝桥杯VIP真题以及数据结构训练资料"是一个专为准备蓝桥杯比赛和提升数据结构技能的宝贵资源。蓝桥杯是一项全国性的编程竞赛，旨在检验参赛者的算法和编程能力，尤其是数据结构的理解与应用。这个压缩包包含了...
python蓝桥杯省赛刷题总结+真题
最新发布
04-16
【Python蓝桥杯省赛刷题总结】 在Python编程领域，蓝桥杯竞赛是一个非常重要的比赛，它旨在考察参赛者的编程能力、算法理解和问题解决技巧。对于准备参加蓝桥杯省赛的选手来说，深入理解和掌握相关的编程知识是至关...
蓝桥杯（Python）相关知识点记录，包含基础知识点，数据结构等算法实现，真题练习
03-24
蓝桥杯Python相关的知识点记录包括基础知识点、数据结构等算法实现以及真题练习项目说明。以下是对这些内容的简要概述： 一、基础知识点 Python标识符：在Python中，标识符由字母、数字、下划线组成，并且区分大小...
蓝桥杯Python基本数据结构
m0_69831635的博客
02-08 573
#元组(Tuple) #定义 其与列表(List)类似(具体参照主页需要注意结构体1)，不同之处在于元组的元素不能修改，其元素是写在小括号( )里面的，元素之间依旧是用逗号隔开。
蓝桥杯基础数据结构
04-07
蓝桥杯 数据结构
1.4.1-4蓝桥杯——基础数据结构
wmq___123456的博客
03-06 353
（3）a.insert(idx,x)，添加单个元素至id位置（指定了位置）（2）a.pop（idx）,a.pop()是列表自带的删除，有返回值。注意：要确保a中有x，有则删除，否则报错。注意：a.append(x)，a.expend(x)区别。（2）a.index(a,start,stop)，位置。（3）a.remove（x），删除a中的第一个x。（1）a.append(x)，添加一个元素至末尾。（2）a.extend(x)，添加多个元素至末尾。（1）a.count(x)，次数。求列表长度：len(a)
python算法技巧——链表练习及掌握
weixin_53919192的博客
04-28 1589
本文介绍了链表的一些小练习，希望能帮助你掌握链表~~ 1. 建立链表： 2. 将链表数据反转： 3. 删除链表的节点： 4. 合并两个排序好的链表： 5. 删除重复链表元素 6. 判断链表内容是不是回文： 7. 二进制链表改成整数：
LeetCode-Python 链表专题（思路+代码）
lht0909的博客
04-25 2617
思路+代码（两数相加 两两交换链表中的结点 环状链表 合并有序链表 相交链表 重排链表 翻转链表 k个一组翻转链表）
数据结构：链表（Python语言实现）
2301_76884567的博客
03-16 5548
本文以单链表为例，用python创建一个单链表数据结构，同时定义链表节点的增加、删除、查询和打印操作。
python数据结构——链表（单链表的插入排序法、双链表的操作）
野猫炫的博客
09-21 1919
顺序表和单链表的比较采用的是链式存储结构，使用一组地址任意的存储单元来存放数据元素。在单链表中，存储的每一条数据都是以节点来表示的，每个节点的构成为：元素（存储数据的存储单元） + 指针（存储下一个节点的地址值）。把需要添加进入单链表的数据封装成节点对象判断单链表是否为空表，也就是判断单链表中是否存在节点： a.如果单链表为空表，那么我们就将"添加节点"设置为单链表的首节点和尾节点 b.如果单链表不是空表，那么我们就将"添加节点"放到尾节点的后面，并设置"添加节点"为单链表的尾节 点。
蓝桥杯必会数据结构-栈、队列与优先队列
As_zyh的博客
03-17 1554
一、stack栈 栈的规则就是先进后出FILO(First In Last Out)，即先入栈的元素最后一个出栈，比如子弹的弹夹，先压到底的子弹最后打出。 #include<iostream> #include<stack> using namespace std; int main() { stack<int> s; //使用push()向栈中压入元素 for(int i = 0; i < 5; i++) s.push(i); while(!
链表试题（Python实现）
Zincy星辰
10-21 845
1. 反转链表 2.链表内指定区间反转（反转链表 II） 3. 链表中的节点每k个一组翻转 4. 链表相加（反转链表） 5. 链表的中间结点（快慢指针） 6. 链表中倒数第k个结点（快慢指针） 7. 删除链表的倒数第n个节点（快慢指针） 8. 回文链表（判断是否为回文：快慢指针+反转链表） 9. 合并两个有序链表 10. 合并k个已排序的链表 11. 相交链表（两个链表的公共结点） 12. 判断链表中是否有环（环形链表） 13. 链表中环的入口结点 14. 单链表的排序 15. 链表的奇偶位置重排
Python链表实现与操作详解：蓝桥杯必备基础
Python中，链表作为一种常见的数据结构，被用来解决许多问题，如动态内存管理，插入和删除操作等。本文档详细介绍了如何在Python中使用类（Class）来构建链表及其关键操作。 首先，我们定义了一个`Node`类，它是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

-北天-

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值