链表试题（Python实现）

已于 2023-01-30 13:39:16 修改
阅读量808 收藏 1
点赞数
分类专栏： Python题集 CodeTop手撕代码教程 文章标签： 链表 数据结构
于 2022-10-21 23:12:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52057693/article/details/127441702
版权

目录

1. 反转链表

2. 链表内指定区间反转（反转链表 II）

3. 链表中的节点每k个一组翻转

4. 链表相加（反转链表）

5. 链表的中间结点（快慢指针）

6. 链表中倒数第k个结点（快慢指针）

7. 删除链表的倒数第n个节点（快慢指针）

8. 回文链表（判断是否为回文：快慢指针+反转链表）

9. 合并两个有序链表

10. 合并k个已排序的链表

11. 相交链表（两个链表的公共结点）

12. 判断链表中是否有环（环形链表）

13. 链表中环的入口结点

14. 单链表的排序

15. 链表的奇偶位置重排

16. 删除有序链表中重复的元素

17. 删除有序链表中出现重复的元素

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

1. 反转链表

206. 反转链表 - 力扣（LeetCode）

class Solution:
    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
        res = None
        cur = head
        while cur:
            curNext = cur.next
            cur.next = res
            res = cur
            cur = curNext
        return res

2. 链表内指定区间反转（反转链表 II）

链表内指定区间反转_牛客题霸_牛客网 (nowcoder.com)

class Solution:
    def reverseBetween(self , head: ListNode, m: int, n: int) -> ListNode:
        # [1] 哨兵节点
        dummyNode = ListNode(-1)
        dummyNode.next = head

        # [2] pre指向反转区间的前一个节点
        pre = dummyNode
        for _ in range(m-1):
            pre = pre.next
        
        # [3] cur指向反转区间的第一个节点，开始反转
        cur = pre.next
        for _ in range(n-m):
            curNext = cur.next
            cur.next = curNext.next
            curNext.next = pre.next
            pre.next = curNext
        return dummyNode.next

3. 链表中的节点每k个一组翻转

链表中的节点每k个一组翻转_牛客题霸_牛客网 (nowcoder.com)

递归实现

class Solution:
    def reverseKGroup(self , head: ListNode, k: int) -> ListNode:
        # [1] 找到当前要翻转的尾部
        tail = head
        for _ in range(k):
            # 如果走到链表尾则直接返回结果head
            if tail == None:
                return head
            tail = tail.next
        # [2] 翻转（在到达当前尾节点tail时）
        newHead = None
        cur = head
        while cur != tail:
            curNext = cur.next
            cur.next = newHead
            newHead = cur
            cur = curNext
        # [3] 当前尾指向下一段要翻转的链表
        head.next = self.reverseKGroup(tail, k)
        return newHead

4. 链表相加（反转链表）

链表相加(二)_牛客题霸_牛客网 (nowcoder.com)

class Solution:
    # 反转链表
    def reverse(self, head: ListNode) -> ListNode:
        res = None
        cur = head
        while cur:
            curNext = cur.next
            cur.next = res
            res = cur
            cur = curNext
        return res
    def addInList(self , head1: ListNode, head2: ListNode) -> ListNode:
        if head1 is None: return head2
        if head2 is None: return head1
        # 反转链表
        head1 = self.reverse(head1)
        head2 = self.reverse(head2)
        # 创建头节点
        head = ListNode(-1)
        cur = head
        # 记录进位数
        count = 0
        while head1 is not None or head2 is not None:
            val = count
            if head1 is not None:
                val += head1.val
                head1 = head1.next
            if head2 is not None:
                val += head2.val
                head2 = head2.next
            count = val//10
            cur.next = ListNode(val%10)
            cur = cur.next
        # 判断最终是否需要进位
        if count>0:
            cur.next = ListNode(count)
        return self.reverse(head.next)

5. 链表的中间结点（快慢指针）

876. 链表的中间结点 - 力扣（LeetCode）

class Solution:
    def middleNode(self, head: Optional[ListNode]) -> Optional[ListNode]:
        fast, slow = head, head
        while fast and fast.next:
            fast = fast.next.next
            slow = slow.next
        return slow

6. 链表中倒数第k个结点（快慢指针）

链表中倒数最后k个结点_牛客题霸_牛客网 (nowcoder.com)

class Solution:
    def FindKthToTail(self , pHead: ListNode, k: int) -> ListNode:
        fast, slow = pHead, pHead
        for _ in range(k):
            if not fast:
                return None
            fast = fast.next
        while fast:
            slow = slow.next
            fast = fast.next
        return slow

7. 删除链表的倒数第n个节点（快慢指针）

删除链表的倒数第n个节点_牛客题霸_牛客网 (nowcoder.com)

class Solution:
    def removeNthFromEnd(self , head: ListNode, n: int) -> ListNode:
        if head is None: return None
        slow, fast = head, head
        for _ in range(n):
            fast = fast.next
        # 如果n大于链表的长度，则删除链表的第一个节点（返回head.next）
        if fast is None:
            return head.next
        while fast.next:
            slow = slow.next
            fast = fast.next
        slow.next = slow.next.next
        return head

8. 回文链表（判断是否为回文：快慢指针+反转链表）

234. 回文链表 - 力扣（LeetCode）

快慢指针找到中间结点，然后反转链表，最后判断是否一致

class Solution:
    def isPalindrome(self, head: Optional[ListNode]) -> bool:
        if head is None: return True
        fast = slow = head
        # [1] slow 找到中间结点
        while fast.next and fast.next.next:
            fast = fast.next.next
            slow = slow.next

        # [2] 反转后半段，以newHead为头结点
        newHead = None
        cur = slow.next
        slow.next = None
        while cur:
            curNext = cur.next
            cur.next = newHead
            newHead = cur
            cur = curNext

        # [3] 判断
        while newHead:
            if head.val != newHead.val:
                return False
            head = head.next
            newHead = newHead.next
        return True

 利用Python特性实现：存入数组直接逆置判断

class Solution:
    def isPalindrome(self, head: Optional[ListNode]) -> bool:
        val = []
        while head:
            val.append(head.val)
            head = head.next
        return val == val[::-1]

9. 合并两个有序链表

21. 合并两个有序链表 - 力扣（LeetCode）

class Solution:
    def mergeTwoLists(self, list1: Optional[ListNode], list2: Optional[ListNode]) -> Optional[ListNode]:
        newHead = ListNode(-1)
        cur = newHead
        while list1 and list2:
            if list1.val <= list2.val:
                cur.next = list1
                list1 = list1.next
            else:
                cur.next = list2
                list2 = list2.next
            cur = cur.next
        if list1:
            cur.next = list1
        else:
            cur.next = list2
        return newHead.next

10. 合并k个已排序的链表

合并k个已排序的链表_牛客题霸_牛客网 (nowcoder.com)

思路1：归并+分治

class Solution:
    # 合并两个有序链表
    def mergeTwoLists(self, list1: ListNode, list2: ListNode) -> ListNode:
        newHead = ListNode(-1)
        cur = newHead
        while list1 and list2:
            if list1.val <= list2.val:
                cur.next = list1
                list1 = list1.next
            else:
                cur.next = list2
                list2 = list2.next
            cur = cur.next
        if list1:
            cur.next = list1
        else:
            cur.next = list2
        return newHead.next

    # 合并k个已排序的链表
    def mergeKLists(self, lists: List[ListNode]) -> ListNode:
        return self.divideMerge(lists, 0, len(lists) - 1)

    # 划分合并区间
    def divideMerge(self, lists: List[ListNode], left: int, right: int) -> ListNode:
        if left > right:
            return None
        elif left == right:
            return lists[left]
        # 从中间分成两段，再将合并好的两段合并
        mid = (left + right) // 2
        return self.mergeTwoLists(
            self.divideMerge(lists, left, mid), self.divideMerge(lists, mid + 1, right))

思路2：优先队列（堆）

from queue import PriorityQueue
class Solution:
    def mergeKLists(self , lists: List[ListNode]) -> ListNode:
        # 小根堆
        pg = PriorityQueue()
        # 遍历所有链表第一个元素，不为空则加入小根堆pg
        for i in range(len(lists)):
            if lists[i] is not None:
                pg.put((lists[i].val, i))
                lists[i] = lists[i].next
        # 结果链表
        res = ListNode(-1)
        cur = res
        # 直到小根堆为空
        while not pg.empty():
            # 取出最小元素
            val,idex = pg.get()
            cur.next = ListNode(val)
            cur = cur.next
            # 添加该链表的下一个元素
            if lists[idex] is not None:
                pg.put((lists[idex].val, idex))
                lists[idex] = lists[idex].next
        return res.next

11. 相交链表（两个链表的公共结点）

160. 相交链表 - 力扣（LeetCode）两个链表的第一个公共结点_牛客题霸_牛客网 (nowcoder.com)

a,b分别为两个链表的指针，a走完head1走head2，b走完head2走head1，a和b相遇时即相交。

class Solution:
    def FindFirstCommonNode(self , pHead1 , pHead2 ):
        a , b = pHead1, pHead2
        while a != b:
            # a从pHead1走完，再走pHead2
            if a is not None: a = a.next
            else: a = pHead2
            # b从pHead2走完，再走pHead1
            if b is not None: b = b.next
            else: b = pHead1
        return a
#——————————————简便写法——————————————
class Solution:
    def FindFirstCommonNode(self , pHead1 , pHead2 ):
        a, b = pHead1, pHead2
        while a != b:
            # a从pHead1走完，再走pHead2
            a = a.next if a else pHead2
            # b从pHead2走完，再走pHead1
            b = b.next if b else pHead1
        # 相遇时即为公共结点
        return a

12. 判断链表中是否有环（环形链表）

141. 环形链表 - 力扣（LeetCode）

快慢指针判断

class Solution:
    def hasCycle(self, head: Optional[ListNode]) -> bool:
        if head is None or head.next is None: return False
        fast = slow = head
        while fast and fast.next:
            fast = fast.next.next
            slow = slow.next
            # 注意先走完再判断！
            if fast == slow:
                return True
        return False

用 set() 集合存储所有可能性

class Solution:
    def hasCycle(self, head: Optional[ListNode]) -> bool:
        seen = set()
        while head:
            if head in seen:
                return True
            seen.add(head)
            head = head.next
        return False

13. 链表中环的入口结点

快慢指针第一次相遇时停下来。快指针回到head，与慢指针一起走，再次相遇即为环入口。

class Solution:
    def EntryNodeOfLoop(self, pHead):
        if pHead is None: return None
        fast, slow = pHead, pHead
        while fast and fast.next:
            fast = fast.next.next
            slow = slow.next
            # 停在快慢指针相遇的位置
            if slow == fast: break
        # 如果为 None 则表示不存在环
        if fast is None or fast.next is None: return None

        # 快指针指向 原head
        fast = pHead
        # 快慢指针同步走，再次相遇时结点为入口结点
        while fast != slow:
            fast = fast.next
            slow = slow.next
        return fast

set()集合得到入口

class Solution:
    def EntryNodeOfLoop(self, pHead):
        ss =set()
        while pHead:
            if pHead not in ss:
                ss.add(pHead)
                pHead = pHead.next
            else:
                return pHead
        return None

14. 单链表的排序

单链表的排序_牛客题霸_牛客网 (nowcoder.com)

存入数组进行排序

class Solution:
    def sortInList(self , head: ListNode) -> ListNode:
        # 存入数组
        tmp = []
        while head:
            tmp.append(head.val)
            head = head.next
        # 数组排序
        tmp.sort()
        # 构建结果链表
        res = ListNode(-1)
        cur = res
        for i in tmp:
            cur.next = ListNode(i)
            cur = cur.next
        return res.next

归并排序（递归）

class Solution:
    # 合并两个有序链表
    def merge(self, head1: ListNode, head2: ListNode) -> ListNode:
        if head1 is None: return head2
        if head2 is None: return head1
        res = ListNode(-1)
        cur = res
        while head1 and head2:
            if head1.val <= head2.val:
                cur.next = head1
                head1 = head1.next
            else:
                cur.next = head2
                head2 = head2.next
            cur = cur.next
        cur.next = head1 if head1 else head2
        return res.next

    def sortInList(self , head: ListNode) -> ListNode:
        if head is None or head.next is None: return head
        premid = head
        mid = head.next
        fast = head.next.next
        # 快边指针到达末尾时，中间指针为链表的中间
        while fast and fast.next:
            premid = premid.next
            mid = mid.next
            fast = fast.next.next
        # 左边链表从中间断开
        premid.next = None
        return self.merge(self.sortInList(head), self.sortInList(mid))

15. 链表的奇偶位置重排

链表的奇偶重排_牛客题霸_牛客网 (nowcoder.com)

class Solution:
    def oddEvenList(self , head: ListNode) -> ListNode:
        if head is None or head.next is None: return head
        odd = head
        even = head.next
        evenHead = even
        while even and even.next:
            # odd连接偶数位的下一个
            odd.next = even.next
            odd = odd.next
            # even连接奇数位的下一个
            even.next = odd.next
            even = even.next
        odd.next = evenHead
        return head

16. 删除有序链表中重复的元素

删除有序链表中重复的元素-I_牛客题霸_牛客网 (nowcoder.com)

class Solution:
    def deleteDuplicates(self , head: ListNode) -> ListNode:
        if head is None or head.next is None: return head
        cur = head
        while cur and cur.next:
            if cur.val == cur.next.val:
                cur.next = cur.next.next
            else:
                cur = cur.next
        return head

17. 删除有序链表中出现重复的元素

删除有序链表中重复的元素-II_牛客题霸_牛客网 (nowcoder.com)

class Solution:
    def deleteDuplicates(self , head: ListNode) -> ListNode:
        if head is None or head.next is None: return head
        res = ListNode(-1)
        res.next = head
        cur = res
        while cur.next and cur.next.next:
            if cur.next.val == cur.next.next.val:
                tmp = cur.next.val
                # 将所有相同的都跳过
                while cur.next is not None and cur.next.val == tmp:
                    cur.next = cur.next.next
            else:
                cur = cur.next
        return res.next

Zincy星辰
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python算法题 链表反转详解
09-19
主要介绍了python算法题 链表反转,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
python链表_实例详解Python实现数据结构线性链表（单链表）算法
weixin_39618597的博客
11-23 174
Python实现数据结构线性链表（单链表）算法示例本文实例讲述了Python实现数据结构线性链表（单链表）算法。分享给大家供大家参考，具体如下：初学python，拿数据结构中的线性链表存储结构练练手，理论比较简单，直接上代码。#!/usr/bin/python# -*- coding:utf-8 -*-# Author: Hui# Date: 2017-10-13# 结点类，class Node...
python链表及其相关题目（更新中）
Yzy_fulture的博客
01-13 1358
链表1. 链表简介1.1 定义：二级目录三级目录 1. 链表简介 1.1 定义： 链表（Linked List）：一种线性存储结构。它使用一组任意的存储单元（可以是连续的或不连续的），来存储一组具有相同类型的数据 链表，是实现线性表的链式存储结构的基础 二级目录 三级目录 ...
Python数据结构与算法篇（十一）-- 链表的应用与常见题型
CarpeDiem
03-14 1671
本篇信息量巨大，首先对比链表和数组，接着解决单链表的反转、删除某一节点、插入数据、查找中间节点、求倒数第k个结点、对称链表、单链表是否有环、两个链表是否相交，最后用LeetCode上的真题来实战删除链表结点、反转链表、合并、排序、环形链表常用技巧。
Leetcode题目：python 实现链表题目合集(边做边更新)
weixin_43585712的博客
04-22 770
思路及注意点（新手走的弯路）： 1.一定要明确l1,l2链表是不可以在尾部加新节点的，因为最后一个指针值为None。 2.保存结果的链表必须满足在尾部添加节点，因为进位的时候要加1，利用ListNode()可以完成动态添加节点。 3.遍历2个链表，先走完的默认值为0，当另一个也走完的时候，一定要注意不要再加新节点了，此可结果链表的长度等于l1，l2中最长的那个。 4.遍历完后，判断是否需要进位，进位则加一个新节点，并赋值为1。 下面的程序是调试的所有代码。 "=====================..
LeetCode-Python 链表专题（思路+代码）
lht0909的博客
04-25 2486
思路+代码（两数相加 两两交换链表中的结点 环状链表 合并有序链表 相交链表 重排链表 翻转链表 k个一组翻转链表）
「代码随想录」Python刷题笔记Day4-链表专题
weixin_44622140的博客
05-28 114
如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。给定一个链表的头节点 head ，返回链表开始入环的第一个节点。如果链表无环，则返回 null。给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
使用python实现链表操作
09-20
链表是计算机科学里面应用最广泛的数据结构之一。这篇文章主要介绍了使用python实现链表操作,需要的朋友可以参考下
python实现链表去重
09-16
链表去重 链表去重是指从一个链表中删除重复出现的元素，使得链表中的每个元素都是唯一的。
python 实现反向输出链表
06-08
# 题目：反向输出一个链表。
python 实现创建链表
06-08
# 题目：创建一个链表。
Python 实现链表实例代码
01-20
Python 实现链表实例代码 前言 算法和数据结构是一个亘古不变的话题，作为一个程序员，掌握常用的数据结构实现是非常非常的有必要的。 实现清单 实现链表，本质上和语言是无关的。但是灵活度却和实现它的语言密切...
【LeetCode刷题】链表专题（一）（附Python代码）
D2Ooo的博客
08-05 253
链表是由一堆 ListNode 构成的，每个 ListNode 记录了val 和 next 信息。如果是双链表的话，还会额外记录prev信息。因此，只要给出头结点（Head）的信息，就可以找到整个列表了。
9 道经典单链表题目助你领略单链表逻辑结构的 “魅力”
honglan297的博客
08-01 629
上一篇文章，我们具体讲述了链表的相关知识。本篇紧承上集，通过 9 道单链表较为 ”简单“ 的题目的讲解，让你领略单链表的别样的逻辑结构 “魅力“。同时，单链表作为笔试常考话题之一，简单题目的回顾希望能够帮助大家夯实操作单链表的基础...
单链表面试题目，python解法
MyGdWcj的博客
10-19 25
方法2：由于方法1创建了新的额外数组，空间复杂度大，所以可以使用方法2，空间复杂都为O(1)，只需创建6个变量，sh，st为小于部分的头和尾，eh，et为等于部分的头和尾，bh和bt为大于部分的头和尾。方法1：可以创建一个数组，将链表中的值放到数组中，在数组中判断非常简单，将数组反转后看是否相等即可，笔试的时候可以用，代码简单，但空间复杂度为O(N)。2、然后用双指针的方法，将数组划分为小于，等于，大于pivot的形式。题目二：给定值pivot，将链表划分为小于，等于，大于pivot的形式。
LeetCode 常见链表问题 （python实现）
weixin_46391502的博客
06-03 404
链表 链表问题很多可以采用递归进行操作。递归理清思路的时候，主要考虑问题最简单的情况。当只有一个节点或两个节点的时候，问题是如何解决的。理清递归退出的条件，可以更加清晰代码的作用。 1. 找出两个链表的交点 LeetCode 160 Easy 问题的核心思想是：两个链表被分成三个部分，a、b、c. 如果他们有共同的交点那么一定有公式a+c+b=b+c+aa+c+b = b+c+aa+c+b=b+c+a，因此当a链表循环到末尾时，跳转到b链表上。那么他们一定会同时到达同一个节点上去。 如果不存在共同链c，
Python 数据库——链表
思则变的专栏
09-12 2320
链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表在逻辑上是连续的，但是在物理空间上可能是不连续的，因为链表的内存都是临时申请的，不一定会申请到连续的内存空间。常用的链表有单向链表和双向链表。这里主要介绍单项链表。单项链表的组成节点有两部分构成：数据和下一个列表的存储地址。单节点结构图：链表结构图：可以看到每一个节点中的addr都指向下一个节点的地址，phead为整个链表的头节点，不能改变，否则就会找不到整个链表。
python单链表实现具体例子_Python单链表实现
weixin_39949607的博客
11-25 141
classNode():def __init__(self,InitDate):self.Date=InitDateself.next=NonedefsetNext(self,newnext):self.next=newnextdefsetDate(self,newDate):self.Date=newDatedefgetNext(self):returnself.nextdefgetDate(s...
数据结构 | 详解栈实现队列&队列实现栈
最新发布
mooridy的博客
05-17 327
step2：此时非空队列中剩下的唯一一个数就是“栈顶”元素，使用QueueFront进行·取值后，直接进行QueuePop删除。step0.先利用假设法假定非空队列notempty和空队列empty，再利用MyStackEmpty函数对进行修正。step1:将notempty队列中的前size-1个元素依次push到empty队列中，再进行删除，实现移动操作。
链表 python 实现
11-23
以下是用Python实现链表的示例代码： ```python # 定义链表节点类 class ListNode: def __init__(self, val=None): self.val = val self.next = None # 定义链表类 class LinkedList: def __init__(self): ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值