【日常系列】LeetCode《14·链表1》

最新推荐文章于 2024-11-17 18:49:52 发布
最新推荐文章于 2024-11-17 18:49:52 发布
阅读量193 收藏
点赞数
分类专栏： 《数据结构与算法入门》 文章标签： 链表 leetcode 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42889517/article/details/127176359
版权

数据规模->时间复杂度

<=10^4 😮(n^2)
<=10^7:o(nlogn)
<=10^8:o(n)
10^8<=:o(logn),o(1)

整体内容

在这里插入图片描述

lc 203 ：移除链表元素
https://leetcode.cn/problems/remove-linked-list-elements/
提示：
列表中的节点数目在范围 [0, 104] 内
1 <= Node.val <= 50
0 <= val <= 50
在这里插入图片描述
在这里插入图片描述在这里插入图片描述

#方案一：删除表头元素与非表头元素
# 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 head!=None and head.val==val:
            delnode=head #key
            head=head.next
            delnode.next=None

        #删表中
        if head==None:return None #key:head是指向第一个元素的，若此时为None,则没有next属性
        prev=head
        curr=head.next
        while curr:
            if curr.val==val:
                prev.next=curr.next
                curr.next=None
                curr=prev.next
            else:
                prev=curr
                curr=curr.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]:
        #建虚拟节点
        dummynode=ListNode(-1)
        dummynode.next=head
        #统一删除逻辑
        prev=dummynode
        curr=head
        while curr:
            if curr.val==val:
                prev.next=curr.next
                curr.next=None
                curr=prev.next
            else:
                prev=curr
                curr=curr.next
        return dummynode.next

在这里插入图片描述

lc 237 删除链表中的节点
https://leetcode.cn/problems/delete-node-in-a-linked-list/
提示：
链表中节点的数目范围是 [2, 1000]
-1000 <= Node.val <= 1000
链表中每个节点的值都是 唯一 的
需要删除的节点 node 是 链表中的节点 ，且 不是末尾节点

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

class Solution:
    def deleteNode(self, node):
        """
        :type node: ListNode
        :rtype: void Do not return anything, modify node in-place instead.
        """
        while node:
            nextnode=node.next
            if nextnode:
                node.val=nextnode.val        
            else:
                prev.next=None
            #注:位置
            prev=node
            node=node.next       
             
#方案二：
# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None
class Solution:
    def deleteNode(self, node):
        """
        :type node: ListNode
        :rtype: void Do not return anything, modify node in-place instead.
        """
        #
        node.val=node.next.val
        #
        nextN=node.next #注：标记
        node.next=nextN.next
        nextN.next=None #node.next.next=None会报错

lc 83 ：删除排序链表中的重复元素
https://leetcode.cn/problems/remove-duplicates-from-sorted-list/
提示：
链表中节点数目在范围 [0, 300] 内
-100 <= Node.val <= 100
题目数据保证链表已经按升序 排列
在这里插入图片描述

# 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==None or head.next==None:return head
        #
        prev=head
        curr=prev.next
        while curr:
            if curr.val==prev.val:
                prev.next=curr.next
                curr.next=None
                curr=prev.next
            else:
                prev=curr
                curr=prev.next
        return head

lc 82 ：删除排序链表中的重复元素 II
https://leetcode.cn/problems/remove-duplicates-from-sorted-list-ii/
提示：
链表中节点数目在范围 [0, 300] 内
-100 <= Node.val <= 100
题目数据保证链表已经按升序 排列
在这里插入图片描述

# 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==None or head.next==None:return head
        #
        dummynode=ListNode(-1)
        dummynode.next=head
        #
        prev=dummynode
        curr=head
        while curr:
            if curr.next and curr.next.val==curr.val:
                while curr.next and curr.next.val==curr.val:
                    curr=curr.next
                prev.next=curr.next
                curr.next=None
                curr=prev.next
            else:
                prev=curr
                curr=curr.next #curr=prev.next,可以和if里合并
        return dummynode.next

lc 876 ：链表的中间结点
https://leetcode.cn/problems/middle-of-the-linked-list/
提示：
给定链表的结点数介于 1 和 100 之间。
在这里插入图片描述在这里插入图片描述

#方案一：两遍扫描
# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def middleNode(self, head: ListNode) -> ListNode:
        #链长
        length=0
        curr=head
        while curr:
            length+=1
            curr=curr.next
        #找
        for i in range(length//2):
            head=head.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 middleNode(self, head: ListNode) -> ListNode:
        if head==None or head.next==None:return head
        slow=fast=head
        while fast and fast.next:#逆否命题
            slow=slow.next
            fast=fast.next.next
        return slow

19 【剑指 021】【top100】 ：删除链表的倒数第 N 个结点
https://leetcode.cn/problems/remove-nth-node-from-end-of-list/
提示：
链表中结点的数目为 sz
1 <= sz <= 30
0 <= Node.val <= 100
1 <= n <= sz
进阶：
你能尝试使用一趟扫描实现吗？
在这里插入图片描述

#方案一：两遍扫描
# 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: Optional[ListNode], n: int) -> Optional[ListNode]:
        #
        dummynode=ListNode(-1)
        dummynode.next=head
        #链长
        length=0
        curr=dummynode
        while curr:
            length+=1
            curr=curr.next
        #找待删prev
        prev=dummynode
        for i in range(length-n-1):
            prev=prev.next
        #删
        delnode=prev.next
        prev.next=delnode.next
        delnode.next=None
        return dummynode.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: Optional[ListNode], n: int) -> Optional[ListNode]:
        if not head:return head
        #
        dummynode=ListNode(-1)
        dummynode.next=head
        #fast先走n+1步
        slow=fast=dummynode
        for i in range(n+1):
            fast=fast.next
        # while n >= 0:
        #     fast = fast.next
        #     n -= 1
        while fast:
            slow=slow.next
            fast=fast.next
        #删:此时prev=slow
        delnode=slow.next
        slow.next=delnode.next
        delnode.next=None
        return dummynode.next

lc 141【top100】：环形链表
https://leetcode.cn/problems/linked-list-cycle/
提示：
链表中节点的数目范围是 [0, 104]
-105 <= Node.val <= 105
pos 为 -1 或者链表中的一个 有效索引 。
进阶：
你能用 O(1)（即，常量）内存解决此问题吗？
在这里插入图片描述

#方案一：hash查找
# 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:
        #o(n),o(n)
        visited=set()
        curr=head
        while curr:
            if curr in visited:return True
            visited.add(curr)
            curr=curr.next
        return False
#方案二：快慢指针
# 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:
        #o(n),o(1)
        slow=head
        fast=head
        while fast and fast.next:
            slow=slow.next
            fast=fast.next.next
            if slow==fast:return True
        return False

lc 142 【剑指 022 】【top100】：环形链表 II
https://leetcode.cn/problems/linked-list-cycle-ii/
提示：
链表中节点的数目范围在范围 [0, 104] 内
-105 <= Node.val <= 105
pos 的值为 -1 或者链表中的一个有效索引
进阶：
你是否可以使用 O(1) 空间解决此题？
在这里插入图片描述

#方案一：hash查找
# 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]:
    	#o(n),o(n)
        visited=set()
        curr=head
        while curr:
            if curr in visited:return curr
            visited.add(curr)
            curr=curr.next
        return None
        
#方案二：快慢指针
# 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]:
        #o(n).o(1)
        slow=fast=head
        while fast and fast.next:
            slow=slow.next
            fast=fast.next.next
            #有环
            if slow==fast:
                p=head
                while p!=slow:
                    p=p.next
                    slow=slow.next
                return p
        return None

lc 206【剑指 024】【top100】：反转链表
https://leetcode.cn/problems/reverse-linked-list/
提示：
链表中节点的数目范围是 [0, 5000]
-5000 <= Node.val <= 5000
进阶：
链表可以选用迭代或递归方式完成反转。你能否用两种方法解决这道题？
在这里插入图片描述在这里插入图片描述
在这里插入图片描述在这里插入图片描述

#方案一：迭代
# 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
        curr=head
        while curr:
            nextN=curr.next
            curr.next=prev
            prev=curr
            curr=nextN
        return prev #key
        
#方案二：递归
# 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]:
        #终条
        if not head or not head.next:return head
        #递
        p=self.reverseList(head.next)#子问题
        #归
        head.next.next=head
        head.next=None
        return p

lc 92 ：反转链表 II
https://leetcode.cn/problems/reverse-linked-list-ii/
提示：
链表中节点数目为 n
1 <= n <= 500
-500 <= Node.val <= 500
1 <= left <= right <= n
进阶：
你可以使用一趟扫描完成反转吗？
在这里插入图片描述在这里插入图片描述在这里插入图片描述

#方案一：
# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def reverseBetween(self, head: Optional[ListNode], left: int, right: int) -> Optional[ListNode]:
        #
        dummynode=ListNode(-1)
        dummynode.next=head
        #四个位置
        #
        prev=dummynode
        for i in range(left-1):
            prev=prev.next
        leftN=prev.next
        #
        rightN=leftN
        for i in range(right-left):
            rightN=rightN.next
        post=rightN.next
        #先断
        prev.next=None
        rightN.next=None
        #部分反转
        self.reverseList(leftN)
        #后连
        prev.next=rightN
        leftN.next=post
        return dummynode.next

    def reverseList(self,node):
        prev=None
        curr=node
        while curr:
            nextN=curr.next
            curr.next=prev
            prev=curr
            curr=nextN

#方案二：头插法
# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def reverseBetween(self, head: Optional[ListNode], left: int, right: int) -> Optional[ListNode]:
        #
        dummynode=ListNode(-1)
        dummynode.next=head
        #
        prev=dummynode
        for i in range(left-1):
            prev=prev.next
        curr=prev.next
        #头插
        for i in range(right-left): #头插right-left次
            nextN=curr.next
            curr.next=nextN.next
            nextN.next=prev.next
            prev.next=nextN
        return dummynode.next

lc 61 ：旋转链表
https://leetcode.cn/problems/rotate-list/
提示：
链表中节点的数目在范围 [0, 500] 内
-100 <= Node.val <= 100
0 <= k <= 2 * 10^9
在这里插入图片描述在这里插入图片描述

#方案一:链表反转法
# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def rotateRight(self, head: Optional[ListNode], k: int) -> Optional[ListNode]:
        if not head or not head.next or k==0:return head    
        #
        length=0
        curr=head
        while curr:
            length+=1
            curr=curr.next
        #改进
        if k%length==0:return head
        k=k%length

        #反1
        newhead1=self.reverseList(head)
        #断
        kthnode=newhead1
        for i in range(k-1):
            kthnode=kthnode.next
        nexthead=kthnode.next
        kthnode.next=None
        #反2，反3,连
        reshead=self.reverseList(newhead1)
        newhead1.next=self.reverseList(nexthead)
        return reshead
        
    def reverseList(self,node):
        prev=None
        curr=node
        while curr:
            nextN=curr.next
            curr.next=prev
            prev=curr
            curr=nextN
        return prev
         
#方案二：处理关键节点
# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def rotateRight(self, head: Optional[ListNode], k: int) -> Optional[ListNode]:
        if not head or not head.next or k==0:return head    
        ###
        #三个位置
        #lastnode
        length=1
        lastnode=head
        while lastnode.next: #key
            length+=1
            lastnode=lastnode.next
        #lasttail,newhead
        if k%length==0:return head
        k=k%length
        lasttail=head
        for i in range(length-k-1):
            lasttail=lasttail.next
        newhead=lasttail.next
        ###
        #
        lastnode.next=head
        lasttail.next=None
        return newhead

lc 328 ：奇偶链表
https://leetcode.cn/problems/odd-even-linked-list/
提示:
n == 链表中的节点数
0 <= n <= 10^4
-10^6 <= Node.val <= 10^6
你必须在 O(1) 的额外空间复杂度和 O(n) 的时间复杂度下解决这个问题。
在这里插入图片描述

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def oddEvenList(self, head: Optional[ListNode]) -> Optional[ListNode]:
        if not head or not head.next or not head.next.next:return head
        #
        odd,even=head,head.next
        evenhead=head.next
        #
        while even and even.next:
            odd.next=even.next
            odd=odd.next
            even.next=odd.next
            even=even.next
        odd.next=evenhead
        return head

lc 725 ：分隔链表
https://leetcode.cn/problems/split-linked-list-in-parts/
提示：
链表中节点的数目在范围 [0, 1000]
0 <= Node.val <= 1000
1 <= k <= 50
在这里插入图片描述
在这里插入图片描述在这里插入图片描述

#方案一：
# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def splitListToParts(self, head: Optional[ListNode], k: int) -> List[Optional[ListNode]]:
        #O(n),o(n)
        length=0
        curr=head
        while curr:
            length+=1
            curr=curr.next
        #
        width=length//k
        remain=length%k #remain个长度为width+1的子链表
        #
        res=[ListNode(-1)]*k #key
        curr=head
        for i in range(k):
            dummynode=ListNode(-1)
            node=dummynode
            #
            realwidth=width+(1 if i<=remain-1 else 0)
            for j in range(realwidth):
                node.next=ListNode(curr.val)
                node=node.next
                if curr:curr=curr.next
            res[i]=dummynode.next
        return res
        
#方案二：原链表中分割
# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def splitListToParts(self, head: Optional[ListNode], k: int) -> List[Optional[ListNode]]:
        #
        length=0
        curr=head
        while curr:
            length+=1
            curr=curr.next
        #
        width=length//k
        remain=length%k #remain个长度为width+1的子链表
        #
        res=[ListNode(-1)]*k #key
        curr=head
        for i in range(k):
            head=curr #key
            realwidth=width+(1 if i<=remain-1 else 0) 
            #
            for j in range(realwidth-1):#key
                if curr:curr=curr.next
            #注：if curr.next:->output[[1],[2],[3],[3],[3]] real[[1],[2],[3],[],[]]
            if curr:
                nextN=curr.next
                curr.next=None
                curr=nextN
            res[i]=head
        return res

lc 24 ：两两交换链表中的节点
https://leetcode.cn/problems/swap-nodes-in-pairs/
提示：
链表中节点的数目在范围 [0, 100] 内
0 <= Node.val <= 100
在这里插入图片描述
在这里插入图片描述

# 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: Optional[ListNode]) -> Optional[ListNode]:
        if not head or not head.next:return head
        #
        dummynode=ListNode(-1)
        dummynode.next=head
        #
        prev=dummynode
        first=head
        second=head.next
        while first and second:
            nextN=second.next
            prev.next=second
            second.next=first
            first.next=nextN
            #
            prev=first
            first=nextN
            if not first:break #key
            second=first.next
        return dummynode.next

lc 25 ：K 个一组翻转链表
https://leetcode.cn/problems/reverse-nodes-in-k-group/
提示：
链表中的节点数目为 n
1 <= k <= n <= 5000
0 <= Node.val <= 1000
进阶：
你可以设计一个只用 O(1) 额外内存空间的算法解决此问题吗？
在这里插入图片描述
在这里插入图片描述

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def reverseKGroup(self, head: Optional[ListNode], k: int) -> Optional[ListNode]:
        #
        if not head or not head.next or k<=1:return head
        dummynode=ListNode(-1)
        dummynode.next=head
        #
        prev=dummynode
        first=head
        last=first
        while first:
            #
            for i in range(k-1):
                last=last.next
                if not last:return dummynode.next
            nextN=last.next
            ###反转
            last.next=None
            self.reverseList(first)
            prev.next=last
            first.next=nextN
            ###更新
            prev=first
            first=nextN
            last=first
        return dummynode.next


    def reverseList(self,node):
        prev=None
        curr=node
        while curr:
            nextN=curr.next
            curr.next=prev
            prev=curr
            curr=nextN
        return prev
常某某的好奇心
关注
专栏目录
算法系列——删除链表中的节点
BridgeGeorge
05-12 727
题目 题目链接：https://leetcode.cn/problems/delete-node-in-a-linked-list 请编写一个函数，用于 删除单链表中某个特定节点 。在设计函数时需要注意，你无法访问链表的头节点 head ，只能直接访问 要被删除的节点 。 题目数据保证需要删除的节点 不是末尾节点 。 思路 以通过修改node 的next 指针的指向，删除 node 的下一个节点。但是题目要求删除 node，为了达到删除node 的效果，只要在删除节点之前，将 node 的节点值修改为 no
判断链表是否为回文链表leetcode-daily-algorithm:简单算法的日常练习
07-01
判断链表是否为回文链表 leetcode 最近，我发现自己很笨拙(╯`□′)╯(┻━┻。 所以我决定做一些练习来唤起我的智慧。 好的，开始吧~ ps：请原谅我可怜的英语 :) ＃目录： ##day1 这个算法是要计算一个等差数列的...
双向链表删除节点时间复杂度_[LeetCode 237] 删除链表中的节点
weixin_39597399的博客
12-03 239
[LeetCode 237] 删除链表中的节点题目描述请编写一个函数，使其可以删除某个链表中给定的（非末尾）节点，你将只被给定要求被删除的节点。现有一个链表 -- head = [4,5,1,9]，它可以表示为:示例 1:输入: head = [4,5,1,9], node = 5 输出: [4,1,9] 解释: 给定你链表中值为 5 的第二个节点，那么在调用了你的函数之后，该链表应变为 4 -&...
【Leetcode】链表专题
weixin_46042619的博客
04-14 1006
迭代法（Iteration）和递归法（Recursion）都是解决问题的方法，它们在编程中经常被用到。迭代法是通过循环的方式，重复执行某段代码直到满足条件为止。通常使用迭代语句（如for循环或while循环）来实现。迭代法通常比递归法更直观，更容易理解，并且在一些情况下效率更高。它的实现方式类似于人们在日常生活中的思考方式，一步一步地解决问题。递归法则是指一个函数在执行过程中调用自己的编程技巧。递归的本质是将问题划分为规模更小的子问题，并不断地重复这个过程直到达到最基本的情况，然后逐层返回结果。
LeetCode链表集锦
如风暖阳的博客
07-04 277
LeetCode链表集锦
LeetCode - 环形链表
小小太空人的博客
04-26 458
我们考虑使用追及相遇来解决。我们使用快慢指针fast和slow，初始化它们都为头结点，然后让slow一次走一步，fast一次走两步，当slow进环时，fast肯定在环里，这个时候它们开始追及。因为fast的步长是slow的两倍，所以它们之间的距离每走一次是减小1的，它们之间的距离逐渐逼近，这样slow和fast一定可以相遇。当它们距离减小到0时，即它们相遇，这个时候就可以确定链表肯定有环。
LeetCode如何构建链表和树的测试用例
dev_zyx的博客
02-14 4116
平时在刷leetcode题目中的链表和树时，难免会出现调试不方便的问题。因为习惯了IDEA中debug来进行错误分析，所以本文将实现leetcode刷题中链表和数在IDEA中的调试。 链表 直接上代码。 public static class ListNode{ int val; ListNode next; ListNode(int x) { v...
【日常系列】LeetCode《15·链表2》
qq_42889517的博客
10-10 139
lc 23【剑指 078】【top100】：合并K个升序链表。lc 21【剑指 25】【top100】：合并两个有序链表。lc 234【剑指 027 】【top100】：回文链表。lc 160【剑指 023】【top100】：相交链表。lc 148【剑指 077】【top100】：排序链表。链表中节点的数目在范围 [0, 5 * 10^4] 内。每个链表中的节点数在范围 [1, 100] 内。链表中节点的数目在范围 [0, 200] 内。链表中节点数目在范围[1, 10^5] 内。
leetcode 倒序链表 两数相加
qq_44904820的博客
07-15 258
两数相加 题目: 我的解法: /** * @Description TODO * @Param [l1, l2] * @return arrays.addTwoNumbers.ListNode * @date 2020/7/14 17:21 * @author huanl * * 思路:先把他全部拿出来,拿出来的时候用字符串的append函数连接起来,后面再用reverse去反转.在把他们相加的到的 * 数转换为StringBuilder类型,然后反转,然
leetcode链表之两数相加
溪语流沙的博客
03-13 200
Leetcode链表专题 文章出现的代码都是python3 2、两数相加 题目 给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。 请你将两个数相加，并以相同形式返回一个表示和的链表。 你可以假设除了数字 0 之外，这两个数都不会以 0 开头。 示例1： 输入：l1 = [2,4,3], l2 = [5,6,4] 输出：[7,0,8] 解释：342 + 465 = 807. 示例2： 输入：l1 = [0], l2 = [0] 输出：[
leetcode算法题-链表操作（两数相加）
12-20
在LeetCode上，有一道经典的算法题，名为“两数相加”（Add Two Numbers）。题目要求使用两个非空的链表来表示两个非负整数，这些整数的每一位都是逆序存储的，即链表的头部表示最高位。每个链表节点仅能存储一个...
判断链表是否为回文链表leetcode-LeetCode:leetcode日常乐趣
07-01
判断链表是否为回文链表 leetcode LeetCode leetcode dayly fun koltin解leetcode 可能时间空间复杂度不是最优的，但是能AC android开发刷题练练手 先easy后medium 最后才考虑hard 主要是锻炼开拓思维和灵活运用各种...
判断链表是否为回文链表leetcode-DailyCodingProblem:日常编码问题
07-01
-1，则链表中没有环。 给定一个整数数组 nums，找出其总和最大的连续子数组（至少包含一个数字）并返回其总和。 给定一个包含城市、供应商名称、价格的 N 个供应商数组和一个包含 M 个寻找酒店的数组，其中 M 个客户...
【LeetCode】70.爬楼梯
weixin_63135906的博客
11-13 455
我们从最后一级台阶n开始分析，有两种方法可以上去，n-1爬一次即可，n-2需要两个台阶即可到达第n个台阶。每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？提交不能通过，超出时间限制了，时间复杂度是O（2^n）在vscode里运行是没有问题的，放到力扣里就报错了。需要 n 阶你才能到达楼顶。当前层爬楼梯方法数等于前两层爬楼梯数相加。注意：给定 n 是一个正整数。： 有两种方法可以爬到楼顶。： 有三种方法可以爬到楼顶。
leetcode LCR 068 搜索插入位置
qq_73454087的博客
11-14 768
已解答简单相关标签相关企业给定一个排序的整数数组nums和一个整数目标值target，请在数组中找到target，并返回其下标。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。请必须使用时间复杂度为O(log n)的算法。21400。
力扣 LeetCode 239. 滑动窗口最大值（Day5：栈与队列）
qq_61504864的博客
11-15 264
可以把 peek() 改为 peekFirst() ，虽然是一个意思，但看起来更加清楚，对于双端队列能更清晰地表述具体操作。始终维护deque的头元素为最大值，后面来的值更大就会逐一清除前面比它小的值。
Leetcode 3356. Zero Array Transformation II
最新发布
codename_cys的博客
11-17 329
Leetcode 3356. Zero Array Transformation II
LeetCode:448找到所有数组中消失的数字——Java哈希表&布尔数组
2301_78566776的博客
11-16 426
最直观的思路是使用哈希集合存储数组 nums 中出现的所有整数，然后遍历 1 到 n 的每个整数并判断是否在哈希集合中，如果一个整数不在哈希集合中则该整数是消失的数字，将该整数添加到结果中。中的数字，并以数组的形式返回结果。数组中对应索引位置的值设置为。如果某个索引位置的值是。中未出现，将其添加到结果列表。，则表示该索引（即数字）在。，表示该索引（即数字）在。
【JavaScript】LeetCode：96-100
weixin_45980065的博客
11-15 999
【代码】【JavaScript】LeetCode：96-100。
链表回文判断与LeetCode日常解题心得
链表是一种常见的基础数据结构，由一系列节点组成，每个节点包含数据部分和指向下一个节点的指针。链表的特点是动态，可以灵活地进行元素的插入和删除操作。在判断链表是否为回文结构的问题中，链表的遍历和指针操作...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值