算法练习--leetcode 链表

news2024/10/7 18:31:39

文章目录

  • 合并两个有序链表
  • 删除排序链表中的重复元素 1
  • 删除排序链表中的重复元素 2
  • 环形链表1
  • 环形链表2
  • 相交链表
  • 反转链表

合并两个有序链表

将两个升序链表合并为一个新的 升序 链表并返回。
新链表是通过拼接给定的两个链表的所有节点组成的。

示例 1：
在这里插入图片描述

输入： l 1 {l1} l1 = [1,2,4], l 2 {l2 } l2= [1,3,4]
输出：[1,1,2,3,4,4]   以列表 表示每个节点的value
 
示例 2：
输入： l 1 {l1} l1 = [], l 2 {l2} l2 = []
输出：[]   表示没有节点 None

示例 3：
输入：l1 = [], l2 = [0]
输出：[0]  表示有一个value为0的节点

提示：
两个链表的节点数目范围是 [0, 50]
-100 <= Node.val <= 100
l1 和 l2 均按 升序排列

python实现：双指针

# Definition for singly-linked list.
# class ListNode:   # 预定义好的  直接用就行
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def mergeTwoLists(self, list1: Optional[ListNode], list2: Optional[ListNode]) -> Optional[ListNode]:   # ListNode or None
        if not list1 and not list2:
            return None  # [] 代表空节点
        elif not list1 or not list2:
            return list1 if list1 else list2
        # 
        header = None
        p = None
        while list1 and list2:
            if list1.val <= list2.val:
                if header is None:
                    header = list1
                    p = list1
                else:
                    p.next = list1
                    p = list1
                list1 = list1.next

            else:
                if header is None:
                    header = list2
                    p = list2
                else:
                    p.next = list2
                    p = list2
                list2 = list2.next

        if list1:
            p.next = list1
        
        elif list2:
            p.next = list2
        
        return header

java实现：
 

删除排序链表中的重复元素 1

给定一个已排序的链表的头 head ， 删除重复的后继元素，使每个元素只出现一次 。返回 已排序的链表 。

示例 1：
在这里插入图片描述

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

示例 2：
在这里插入图片描述

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

python实现：递归算法

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:
        if head is None or head.next is None:
            return head

        # 至少两个节点
        cur = head
        if cur.val == cur.next.val:
            cur.next = cur.next.next
            return self.deleteDuplicates(head)
        else:
            cur.next = self.deleteDuplicates(cur.next)
			return head

java实现：
在这里插入图片描述

 

删除排序链表中的重复元素 2

给一个已排序的链表的头 head ， 删除原始链表中所有 重复数字的节点 ，返回该链表 。

重点：已排序

示例 1：
在这里插入图片描述

输入：head = [1,2,3,3,4,4,5]
输出：[1,2,5]
 
示例 2：
在这里插入图片描述

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

python实现: 递归解决

  • 情况1：删除头节点重复的部分，继续递归处理剩下的部分；
  • 情况2：保留头节点，继续处理剩下的部分
# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:
        if head is None or head.next is None:
            return head
        # 至少两个节点
        cur = head
        if cur.val == cur.next.val: # 要删除头节点
            move = cur.next.next
            while move and cur.val == move.val: # 移动到不相等的节点
                move = move.next
            return self.deleteDuplicates(move)
        else:
            cur.next = self.deleteDuplicates(cur.next) # 保留头节点
        
        return head

同一段程序，多次提交，耗时和击败用户比率会不同；所以不用在乎这个击败比率。
在这里插入图片描述
java实现：
pending

 

环形链表1

给一个链表的头节点 head ，判断链表中是否有环。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。存在环 ，则返回 true 。 否则，返回 false 。

以下pos不作为参数

示例 1：
在这里插入图片描述
输入：head = [3,2,0,-4], pos = 1
输出：true

示例 2：
在这里插入图片描述

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

示例 3：
在这里插入图片描述
输入：head = [1], pos = -1
输出：false
解释：链表中没有环。

进阶：你能用 O(1) 空间复杂度解决此问题吗？

python实现：

# 辅助空间 + 循环
# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def hasCycle(self, head: Optional[ListNode]) -> bool:
        temp = []
        cur = head
        while cur:
            temp.append(cur)
            if cur.next in temp:  # python内置方法也慢
                return True
            cur = cur.next
        return False

# 双指针  一快 一慢   空间复杂度O(1)
# 快走两步  慢走一步  会在环内相遇
# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None
class Solution:
    def hasCycle(self, head: Optional[ListNode]) -> bool:
        if head is None:
            return False
        
        slow_ptr = head  # 一次走一步
        fast_ptr = head  # 一次走两步
        while fast_ptr.next and fast_ptr.next.next:
            slow_ptr = slow_ptr.next
            fast_ptr = fast_ptr.next.next
            if fast_ptr is slow_ptr:
                return True
        
        return False

java双指针
在这里插入图片描述

 

环形链表2

给定一个链表的头节点 head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。
pos不传参，且不允许修改链表

示例 1：
在这里插入图片描述
输入：head = [3,2,0,-4], pos = 1
输出：返回索引为 1 的链表节点
 
示例 2：
在这里插入图片描述
输入：head = [1,2], pos = 0
输出：返回索引为 0 的链表节点
 
示例 3：
在这里插入图片描述

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

# 辅助空间 + 循环
# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None
class Solution:
    def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:
        if head is None:
            return None
        
        temp = []
        cur = head
        while cur:
            temp.append(cur)
            if cur.next in temp:
                return cur.next
            cur = cur.next
        return None

# 双指针  一快一慢   空间复杂度O(1)
# 快指针移动2步
# 漫指针移动1步
# 在环中相遇后，慢指针重置到head指针
# 然后两个指针均移动一步，直到再次相遇，即找到入环的节点
# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None
class Solution:
    def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:
        if head is None:
            return None
        slow_ptr = head
        fast_ptr = head
        has_circle = False
        while fast_ptr.next and fast_ptr.next.next:
            slow_ptr = slow_ptr.next
            fast_ptr = fast_ptr.next.next
            if fast_ptr is slow_ptr:
                has_circle = True
                break
            
        if has_circle:
            # 重置慢指针为head
            slow_ptr = head
            # 两个指针均移动一步，直到相遇
            while slow_ptr is not fast_ptr:
                slow_ptr = slow_ptr.next
                fast_ptr = fast_ptr.next

            # 相遇则为入环节点
            return fast_ptr
        
        return None

优化前后时间对比：
在这里插入图片描述

java实现：
在这里插入图片描述

 

相交链表

给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回 null 。

你能否设计一个时间复杂度 O(m + n) 、仅用 O(1) 内存的解决方案？
m,n 分别为链表A B的节点数。

图示两个链表在节点 c1 开始相交：
在这里插入图片描述

示例 1：
在这里插入图片描述

输入：listA = [4,1,8,4,5], listB = [5,6,1,8,4,5]
skipA = 2, skipB = 3 intersectVal = 8,
输出：node 8 对象

 
示例 2：
在这里插入图片描述
输入：listA = [1,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1 intersectVal = 2,
输出：node 2
 
示例 3：
在这里插入图片描述
输入：listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2 intersectVal = 0,
输出：null

python 实现：
双指针 循环移动 直至相遇

# 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) -> Optional[ListNode]:
        if headA is None or headB is None:
            return None

        pa = headA
        pb = headB
        while pa is not pb:
            pa = pa.next if pa else headB
            pb = pb.next if pb else headA
        
        return pa

也可以计算链表的长度差值，较长的链表指针移动长度差个步子。
 
 

反转链表

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

示例 1：
在这里插入图片描述

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

 
示例 2：
在这里插入图片描述

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

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

进阶：链表可以选用迭代或递归方式完成反转。你能否用两种方法解决这道题？
python实现：

在这里插入代码片

java实现：
在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/851208.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【IMX6ULL驱动开发学习】03.Linux驱动开发之GPIO子系统、中断、定时器

【IMX6ULL驱动开发学习】03.Linux驱动开发之GPIO子系统、中断、定时器

一、GPIO子系统 1.1 引脚编号 在硬件上如何确定GPIO引脚&#xff1f;它属于哪组GPIO&#xff1f;它是这组GPIO里的哪个引脚&#xff1f;需要2个参数。但是在Linux软件上&#xff0c;可以使用引脚编号来表示。以100ask_ imx6ull为例在开发板上执行如下命令查看已经在使用的GPI…
阅读更多...
桥接模式-java实现

桥接模式-java实现

桥接模式 桥接模式的本质&#xff0c;是解决一个基类&#xff0c;存在多个扩展维度的的问题。 比如一个图形基类&#xff0c;从颜色方面扩展和从形状上扩展&#xff0c;我们都需要这两个维度进行扩展&#xff0c;这就意味着&#xff0c;我们需要创建一个图形子类的同时&#x…
阅读更多...
手搓vue3组件_1.封装一个button

手搓vue3组件_1.封装一个button

我的icepro参考地址,内有参考代码,有条件的割割点点star 实现要求: 基于vue3支持通过colors(更改颜色)支持点击事件…支持其他的自定义样式(例如圆角,size等等) 最基础的第一步: 父组件引入并使用: <template><div class"buttonLim">我的按钮:<ice-b…
阅读更多...
Zabbix监控华为交换机DHCP接口地址池

Zabbix监控华为交换机DHCP接口地址池

一、背景 最近工作中遇到一个因为DHCP地址池满载、导致用户无法获取到IP地址的故障&#xff0c;所以在想通过zabbix 监控DHCP地址池的状态、当DHCP 地址池数量小于某个值时触发zabbix告警。 网上找了一下没有相关的文档、和对应的OID值、于是用Python 脚本的方式实现 二、实现效…
阅读更多...
第二课-一键安装SD-Stable Diffusion 教程

第二课-一键安装SD-Stable Diffusion 教程

前言 看完这篇文章并跟着操作，就可以在本地开始 SD 绘图了。 理论上来说，这篇课程结束，想要画什么图都可以画了。 启动器介绍 SD 是开源的，可以在 github 上找到。但直接下载源码安装，非常费劲，而且因为国内外差异，就是我这样的秃头程序员也难以应对。 所以，我们改…
阅读更多...
Spring中Bean的“一生”(生命周期)

Spring中Bean的“一生”(生命周期)

文章目录 一、图解二、文字解析总结 一、图解 >注&#xff1a;处于同一行的执行顺序是从左往右 二、文字解析 SpringBean的生命周期总体分为四个阶段&#xff1a;实例化>属性注入>初始化>销毁 Step1 实例化Bean&#xff1a;根据配置文件中Bean的定义&#xff0c;…
阅读更多...
设计模式（3）装饰模式

设计模式（3）装饰模式

一、介绍&#xff1a; 1、应用场景&#xff1a;把所需的功能按正确的顺序串联起来进行控制。动态地给一个对象添加一些额外的职责&#xff0c;就增加功能来说&#xff0c;装饰模式比生成子类更加灵活。 当需要给一个现有类添加附加职责&#xff0c;而又不能采用生成子类的方法…
阅读更多...
[RCTF2019]DontEatMe

[RCTF2019]DontEatMe

前言 一道迷宫题&#xff0c;但是输入被加密后使用&#xff0c;迷宫也需要在程序中找出并没有直接输出 分析 反调试 发现有两个比较特殊的地方&#xff0c;随机数和创建了新线程&#xff0c;随机数后面又被重新赋值给覆盖了&#xff0c;暂时不用管&#xff0c;ZwSetInformat…
阅读更多...
业务需求紧急,IT部门缺失,企业如何应对＂影子IT＂危机?

业务需求紧急,IT部门缺失,企业如何应对＂影子IT＂危机?

在当今数字化时代&#xff0c;业务部门的需求通常非常紧急&#xff0c;但IT部门的排期却跟不上&#xff0c;导致业务部门焦头烂额。IT部门面临着诸多需求&#xff0c;无法在规定时间范围内满足每一个需求&#xff0c;因此未授权的应用程序安全监管也变得愈发困难。 影子IT的频发…
阅读更多...
互联网电影购票选座后台管理系统源码开发

互联网电影购票选座后台管理系统源码开发

搭建一个互联网电影购票选座后台管理系统需要进行以下步骤&#xff1a; 1. 需求分析&#xff1a;首先要明确系统的功能和需求&#xff0c;包括电影列表管理、场次管理、座位管理、订单管理等。 2. 技术选型&#xff1a;选择适合的技术栈进行开发&#xff0c;包括后端开发语言…
阅读更多...
铸铝齿轮泵比例流量阀放大器

铸铝齿轮泵比例流量阀放大器

液压齿轮泵是一种常用的液压泵&#xff0c;被广泛应用于各种低压系统中&#xff0c;如采矿、冶金、建筑、航空、航海、农林等机械的中、高压液压系统中。 液压齿轮泵的特点是结构简单&#xff0c;制造方便&#xff0c;价格低廉&#xff0c;体积小&#xff0c;重量轻&#xff0…
阅读更多...
探析STM32标准库与HAL库之间的差异与优劣

探析STM32标准库与HAL库之间的差异与优劣

引言&#xff1a; 在嵌入式开发领域&#xff0c;STMicroelectronics的STM32系列芯片广受欢迎。STM32提供了两种主要的软件库&#xff0c;即标准库和HAL库&#xff0c;用于开发各种应用。本文将探讨这两种库之间的差异&#xff0c;比较它们的优劣&#xff0c;并分析在选择库时需…
阅读更多...
[HDLBits] Exams/m2014 q4e

[HDLBits] Exams/m2014 q4e

Implement the following circuit: module top_module (input in1,input in2,output out);assign out!(in1||in2); endmodule
阅读更多...
【MySQL】

【MySQL】

这里写目录标题 MySQL架构一条sql执行流程MySQL数据存放电脑位置ibd文件结构行溢出是什么MySQL行记录存储格式索引为什么InnoDB选择B树作为索引数据结构什么时候需要创建索引优化索引方法InnoDB内部怎么存储数据B 树如何进行查询聚簇索引和二级索引为什么MySQL要采用B树作为索引…
阅读更多...
【linux】ssh 和adb connect区别

【linux】ssh 和adb connect区别

问&#xff1a;ssh 与ping的区别 答&#xff1a;SSH&#xff08;Secure Shell&#xff09;和Ping是两种完全不同的网络工具。 SSH是一种加密的网络协议&#xff0c;用于安全地远程管理或访问远程计算机。它提供了一种安全的通信方式&#xff0c;可以在不安全的网络上进行远程登…
阅读更多...
无涯教程-Perl - fileno函数

无涯教程-Perl - fileno函数

描述 此函数返回指定的FILEHANDLE的文件描述符号(由C和POSIX函数使用)。通常,这仅在使用select函数和任何低级tty函数时才有用。 语法 以下是此函数的简单语法- fileno FILEHANDLE返回值 此函数返回FILEHANDLE的文件描述符(数字),失败时不确定。 Perl 中的 fileno函数 - 无…
阅读更多...
c#设计模式-行为型模式 之 观察者模式

c#设计模式-行为型模式 之 观察者模式

定义&#xff1a; 又被称为发布-订阅&#xff08;Publish/Subscribe&#xff09;模式&#xff0c;它定义了一种一对多的依赖关系&#xff0c;让多个观察者 对象同时监听某一个主题对象。这个主题对象在状态变化时&#xff0c;会通知所有的观察者对象&#xff0c;使他们能够自 …
阅读更多...
Go Gin 中使用 JWT

Go Gin 中使用 JWT

一、JWT JWT全称JSON Web Token是一种跨域认证解决方案&#xff0c;属于一个开放的标准&#xff0c;它规定了一种Token实现方式&#xff0c;目前多用于前后端分离项目和OAuth2.0业务场景下。 二、为什么要用在你的Gin中使用JWT 传统的Cookie-Sesson模式占用服务器内存, 拓展性…
阅读更多...
C++ 多态性——纯虚函数与抽象类

C++ 多态性——纯虚函数与抽象类

抽象类是一种特殊的类&#xff0c;它为一个类族提供统一的操作界面。抽象类是为了抽象和设计的目的而建立的。可以说&#xff0c;建立抽象类&#xff0c;就是为了通过它多态地使用其中的成员函数。抽象类处于类层次的上层&#xff0c;一个抽象类自身无法实例化&#xff0c;也就…
阅读更多...
提升招标文件准确性：校对软件助力招标流程优化

提升招标文件准确性：校对软件助力招标流程优化

招标文件的准确性对于一个招标项目的成功非常重要。校对软件可以在优化招标流程中发挥关键作用&#xff0c;帮助提升招标文件的准确性和质量。以下是一些校对软件如何助力招标流程优化的方式&#xff1a; 1.拼写和语法检查&#xff1a;校对软件可以自动检测和纠正招标文件中的拼…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023