【日常系列】LeetCode《15·链表2》

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

数据规模->时间复杂度

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

lc 234【剑指 027 】【top100】：回文链表
https://leetcode.cn/problems/palindrome-linked-list/
提示：
链表中节点数目在范围[1, 10^5] 内
0 <= Node.val <= 9
进阶：
你能否用 O(n) 时间复杂度和 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 isPalindrome(self, head: Optional[ListNode]) -> bool:
        if not head or not head.next:return True
        #
        slow=head
        fast=head.next
        while fast and fast.next:
            slow=slow.next
            fast=fast.next.next
        newhead=slow.next
        slow.next=None
        #
        left=head
        right=self.reverseList(newhead)
        while right:
            if left.val!=right.val:return False
            left,right=left.next,right.next
        return True
    
    def reverseList(self,node):
        prev=None
        curr=node
        while curr:
            nextN=curr.next
            curr.next=prev
            prev=curr
            curr=nextN
        return prev

lc 138【剑指 35】 ：复制带随机指针的链表
https://leetcode.cn/problems/fu-za-lian-biao-de-fu-zhi-lcof/
提示：
-10000 <= Node.val <= 10000
Node.random 为空（null）或指向链表中的节点。
节点数目不超过 1000 。
在这里插入图片描述在这里插入图片描述在这里插入图片描述
在这里插入图片描述

#方案一：递归
"""
# Definition for a Node.
class Node:
    def __init__(self, x: int, next: 'Node' = None, random: 'Node' = None):
        self.val = int(x)
        self.next = next
        self.random = random
"""

class Solution:
    def __init__(self):
        self.Map={}
    def copyRandomList(self, head: 'Optional[Node]') -> 'Optional[Node]':
        #
        if not head:return head
        #
        newnode=Node(head.val)
        self.Map[head]=newnode #key-key-key:random的映射

        newnode.next=self.copyRandomList(head.next)
        if head.random:
            newnode.random=self.Map[head.random]
        return newnode
        
#方案二：迭代
"""
# Definition for a Node.
class Node:
    def __init__(self, x: int, next: 'Node' = None, random: 'Node' = None):
        self.val = int(x)
        self.next = next
        self.random = random
"""

class Solution:
    def __init__(self):
        self.Map={}
    def copyRandomList(self, head: 'Optional[Node]') -> 'Optional[Node]':
        #
        if not head:return head
        #
        newnode=Node(head.val)
        self.Map[head]=newnode #key-key-key:random的映射
        newhead=newnode
        #
        while head:
            newnode.next=self.get_cloned_node(head.next)
            newnode.random=self.get_cloned_node(head.random)
            newnode=newnode.next
            head=head.next
        return newhead
        
    def get_cloned_node(self,node):
        if not node:return None
        if node not in self.Map:self.Map[node]=Node(node.val) #key-key-key
        return self.Map[node]
       
#方案三：新旧节点交替，代替Map
"""
# Definition for a Node.
class Node:
    def __init__(self, x: int, next: 'Node' = None, random: 'Node' = None):
        self.val = int(x)
        self.next = next
        self.random = random
"""

class Solution:
    def __init__(self):
        self.Map={}
    def copyRandomList(self, head: 'Optional[Node]') -> 'Optional[Node]':
        #
        if not head:return head
        #建立新旧节点交替
        curr=head
        while curr:
            newnode=Node(curr.val)
            newnode.next=curr.next
            curr.next=newnode
            curr=newnode.next
        #设置random
        curr=head
        while curr:
            curr.next.random=curr.random.next if curr.random else None
            curr=curr.next.next
        #分割
        old=head
        new=head.next
        newhead=head.next
        while new:
            old.next=old.next.next
            new.next=new.next.next if new.next else None
            old=old.next
            new=new.next
        return newhead

lc 86 ：分隔链表
https://leetcode.cn/problems/partition-list/
提示：
链表中节点的数目在范围 [0, 200] 内
-100 <= Node.val <= 100
-200 <= x <= 200
在这里插入图片描述在这里插入图片描述

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:
        if not head or not head.next:return head
        #
        smallhead=ListNode(-1)
        small=smallhead
        largehead=ListNode(-1)
        large=largehead
        #
        while head:
            if head.val<x:
                small.next=head
                small=small.next
            else:
                large.next=head
                large=large.next
            head=head.next
        #
        large.next=None    
        small.next=largehead.next
        return smallhead.next

lc 160【剑指 023】【top100】：相交链表
https://leetcode.cn/problems/intersection-of-two-linked-lists/
提示：
listA 中节点数目为 m
listB 中节点数目为 n
1 <= m, n <= 3 * 10^4
1 <= Node.val <= 10^5
0 <= skipA <= m
0 <= skipB <= n
如果 listA 和 listB 没有交点，intersectVal 为 0
如果 listA 和 listB 有交点，intersectVal == listA[skipA] == listB[skipB]
进阶：
你能否设计一个时间复杂度 O(m + n) 、仅用 O(1) 内存的解决方案？
在这里插入图片描述在这里插入图片描述
在这里插入图片描述

#方案一：hash
# 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]:
        common=set()
        while headA:
            common.add(headA)
            headA=headA.next
        while headB:
            if headB in common:return headB
            headB=headB.next
        return None

#方案二：双指针（相交时步数一致）
# 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 not headA or not headB:return None
        a=headA
        b=headB
        while a!=b:
            a=a.next if a else headB
            b=b.next if b else headA
        return a

lc 2 【top100】：两数相加
https://leetcode.cn/problems/add-two-numbers/
提示：
每个链表中的节点数在范围 [1, 100] 内
0 <= Node.val <= 9
题目数据保证列表表示的数字不含前导零
在这里插入图片描述

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:
        #
        dummynode=ListNode(-1)
        curr=dummynode
        carry=0
        while l1 or l2:
            n1=l1.val if l1 else 0
            n2=l2.val if l2 else 0
            sumA=n1+n2+carry
            carry=sumA//10
            #
            curr.next=ListNode(sumA%10)
            #
            curr=curr.next
            l1=l1.next if l1 else None
            l2=l2.next if l2 else None
        if carry==1:curr.next=ListNode(carry)
        return dummynode.next

lc 445【剑指 025】 ：两数相加 II
https://leetcode.cn/problems/add-two-numbers-ii/
提示：
链表的长度范围为 [1, 100]
0 <= node.val <= 9
输入数据保证链表代表的数字无前导 0
进阶：
如果输入链表不能翻转该如何解决？
在这里插入图片描述在这里插入图片描述在这里插入图片描述

#方案一：反转链表
# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:
        newl1=self.reverseList(l1)
        newl2=self.reverseList(l2)
        #
        dummynode=ListNode(-1)
        curr=dummynode
        carry=0
        while newl1 or newl2:
            n1=newl1.val if newl1 else 0
            n2=newl2.val if newl2 else 0
            sum=n1+n2+carry
            curr.next=ListNode(sum%10)
            carry=sum//10
            #
            curr=curr.next
            newl1=newl1.next if newl1 else None
            newl2=newl2.next if newl2 else None
        if carry==1:curr.next=ListNode(carry)
        return self.reverseList(dummynode.next)

    
    def reverseList(self,node):
        prev=None
        curr=node
        while curr:
            next=curr.next
            curr.next=prev
            prev=curr
            curr=next
        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 addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:
        if not l1:return l2
        if not l2:return l1
        #
        stack1=[]
        stack2=[]
        while l1:
            stack1.append(l1)
            l1=l1.next
        while l2:
            stack2.append(l2)
            l2=l2.next 
        #
        dummynode=ListNode(-1)
        curr=dummynode
        carry=0
        while stack1 or stack2:
            n1=stack1.pop().val if stack1 else 0
            n2=stack2.pop().val if stack2 else 0
            sum=n1+n2+carry
            curr.next=ListNode(sum%10)
            carry=sum//10
            #
            curr=curr.next
        if carry==1:curr.next=ListNode(carry)
        return self.reverseList(dummynode.next)

    def reverseList(self,node):
        prev=None
        curr=node
        while curr:
            next=curr.next
            curr.next=prev
            prev=curr
            curr=next
        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 addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:
        if not l1:return l2
        if not l2:return l1
        #
        stack1=[]
        stack2=[]
        while l1:
            stack1.append(l1)
            l1=l1.next
        while l2:
            stack2.append(l2)
            l2=l2.next 
        #
        ans=None
        carry=0
        while stack1 or stack2:
            n1=stack1.pop().val if stack1 else 0
            n2=stack2.pop().val if stack2 else 0
            sum=n1+n2+carry
            curr=ListNode(sum%10)
            curr.next=ans
            carry=sum//10
            #
            ans=curr
        if carry==1:
            curr=ListNode(carry)
            curr.next=ans
            ans=curr
        return ans

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

lc 21【剑指 25】【top100】：合并两个有序链表
https://leetcode.cn/problems/merge-two-sorted-lists/
提示：
两个链表的节点数目范围是 [0, 50]
-100 <= Node.val <= 100
l1 和 l2 均按 非递减顺序 排列
在这里插入图片描述在这里插入图片描述

#方案一：迭代
# 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]:
        #
        if not list1:return list2
        if not list2:return list1
        #
        dummy=ListNode(-1)
        curr=dummy
        while list1 and list2:
            if list1.val <= list2.val:
                curr.next=list1
                list1=list1.next
            else:
                curr.next=list2
                list2=list2.next
            curr=curr.next
        if not list1:curr.next=list2
        if not list2:curr.next=list1
        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 mergeTwoLists(self, list1: Optional[ListNode], list2: Optional[ListNode]) -> Optional[ListNode]:
        #
        if not list1:return list2
        if not list2:return list1
        #
        if list1.val<=list2.val:
            list1.next=self.mergeTwoLists(list1.next,list2)
            return list1
        else:
            list2.next=self.mergeTwoLists(list1,list2.next)
            return list2

lc 23【剑指 078】【top100】：合并K个升序链表
https://leetcode.cn/problems/merge-k-sorted-lists/
提示：
k == lists.length
0 <= k <= 10^4
0 <= lists[i].length <= 500
-10^4 <= lists[i][j] <= 10^4
lists[i] 按 升序 排列
lists[i].length 的总和不超过 10^4
在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述

#方案一：顺序合并
# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def mergeKLists(self, lists: List[Optional[ListNode]]) -> Optional[ListNode]:
        #o((k^2)*n),o(1)
        if len(lists)==0:return None
        outlist=lists[0]
        for i in range(1,len(lists)):
            outlist=self.merge2Lists(outlist,lists[i])
        return outlist
    
    def merge2Lists(self,list1,list2):
        #
        if not list1:return list2
        if not list2:return list1
        #
        if list1.val<=list2.val:
            list1.next=self.merge2Lists(list1.next,list2)
            return list1
        else:
            list2.next=self.merge2Lists(list1,list2.next)
            return list2

#方案二：分治
# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def mergeKLists(self, lists: List[Optional[ListNode]]) -> Optional[ListNode]:
        if len(lists)==0:return None
        return self.merge(lists,0,len(lists)-1)


    def merge(self,lists,left,right):
        #o(kn*logk),o(logk)
        if left==right:return lists[left]
        #if left<right:return None
        #
        mid=left+(right-left)//2
        mergeleft=self.merge(lists,left,mid)
        mergeright=self.merge(lists,mid+1,right)
        return self.merge2Lists(mergeleft,mergeright)

    def merge2Lists(self,list1,list2):
        #
        if not list1:return list2
        if not list2:return list1
        #
        if list1.val<=list2.val:
            list1.next=self.merge2Lists(list1.next,list2)
            return list1
        else:
            list2.next=self.merge2Lists(list1,list2.next)
            return list2

#方案三：优先队列
# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def mergeKLists(self, lists: List[Optional[ListNode]]) -> Optional[ListNode]:
        #o(kn*logk)
        if len(lists)==0:return None
        #
        pq=[]
        for i in range(len(lists)):#o(k)
            if lists[i]:
                heapq.heappush(pq,(lists[i].val,i))#o(logk)
                #key：对应i的位置更新
                lists[i]=lists[i].next
        #
        dummy=ListNode(-1)
        curr=dummy
        while pq:#(kn)
            val,idx=heapq.heappop(pq) #o(logk)
            curr.next=ListNode(val)
            curr=curr.next
            #key:更新队列及对应i的位置
            if lists[idx]:
                heapq.heappush(pq,(lists[idx].val,idx))
                lists[idx]=lists[idx].next
        return dummy.next

lc 147 ：对链表进行插入排序
https://leetcode.cn/problems/insertion-sort-list/
提示：
列表中的节点数在 [1, 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 insertionSortList(self, head: Optional[ListNode]) -> Optional[ListNode]:
        if not head or not head.next:return head
        #
        dummy=ListNode(-1)
        dummy.next=head
        prev=head
        curr=head.next
        #
        while curr:
            if curr.val <prev.val:
                p=dummy
                while p.next and p.next.val<curr.val:
                    p=p.next
                prev.next=curr.next
                curr.next=p.next
                p.next=curr
                #
                curr=prev.next
            else:
                prev=curr
                curr=curr.next
        return dummy.next

lc 148【剑指 077】【top100】：排序链表
https://leetcode.cn/problems/sort-list/
提示：
链表中节点的数目在范围 [0, 5 * 10^4] 内
-10^5 <= Node.val <= 10^5
进阶：
你可以在 O(nlogn) 时间复杂度和常数级空间复杂度下，对链表进行排序吗？
在这里插入图片描述在这里插入图片描述在这里插入图片描述
在这里插入图片描述在这里插入图片描述在这里插入图片描述
在这里插入图片描述在这里插入图片描述

#方案一：递归排序
# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:
        if not head or not head.next:return head
        #割
        left=head
        right=head.next
        while right and right.next:
            left=left.next
            right=right.next.next
        righthead=left.next
        left.next=None
        #分
        leftpart=self.sortList(head)
        rightpart=self.sortList(righthead)
        #合
        return self.merge2List(leftpart,rightpart)
    
    def merge2List(self,list1,list2):
        dummy=ListNode(-1)
        curr=dummy
        while list1 and list2:
            if list1.val <= list2.val:
                curr.next=list1
                list1=list1.next
            else:
                curr.next=list2
                list2=list2.next
            curr=curr.next
        if not list1:curr.next=list2
        if not list2:curr.next=list1
        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 sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:
        if not head or not head.next:return head
        #
        dummy = ListNode(-1)
        dummy.next = head
        #链长
        length = 0
        curr=head
        while curr:
            length += 1
            curr = curr.next
        
        #key:边分-边合
        step = 1
        while step < length:
            prev, curr = dummy, dummy.next #这里curr不为head，因为head会改变
            while curr:
                left = curr
                right = self.split(left, step)
                #下次待处理的链表头
                curr = self.split(right, step)
                #合
                prev = self.merge(left, right, prev)
            step <<= 1
        return dummy.next
  
    #节点切断，返右链头
    def split(self,node,step):#step=1,2,4...
        if not node:return None
        for i in range(step-1):
            if node.next:node=node.next
        right=node.next
        node.next=None
        return right
    
    def merge(self,list1,list2,prev):
        curr=prev
        while list1 and list2:
            if list1.val <= list2.val:
                curr.next=list1
                list1=list1.next
            else:
                curr.next=list2
                list2=list2.next
            curr=curr.next
        if not list1:curr.next=list2
        if not list2:curr.next=list1
        #保证curr最后指向非空链尾
        while curr.next:curr=curr.next
        return curr
常某某的好奇心
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
leetcode算法题-链表操作（两数相加）
12-20
在LeetCode上，有一道经典的算法题，名为“两数相加”（Add Two Numbers）。题目要求使用两个非空的链表来表示两个非负整数，这些整数的每一位都是逆序存储的，即链表的头部表示最高位。每个链表节点仅能存储一个...
判断链表是否为回文链表leetcode-daily-algorithm:简单算法的日常练习
07-01
判断链表是否为回文链表 leetcode 最近，我发现自己很笨拙(╯`□′)╯(┻━┻。 所以我决定做一些练习来唤起我的智慧。 好的，开始吧~ ps：请原谅我可怜的英语 :) ＃目录： ##day1 这个算法是要计算一个等差数列的...
【Leetcode】链表专题
weixin_46042619的博客
04-14 957
迭代法（Iteration）和递归法（Recursion）都是解决问题的方法，它们在编程中经常被用到。迭代法是通过循环的方式，重复执行某段代码直到满足条件为止。通常使用迭代语句（如for循环或while循环）来实现。迭代法通常比递归法更直观，更容易理解，并且在一些情况下效率更高。它的实现方式类似于人们在日常生活中的思考方式，一步一步地解决问题。递归法则是指一个函数在执行过程中调用自己的编程技巧。递归的本质是将问题划分为规模更小的子问题，并不断地重复这个过程直到达到最基本的情况，然后逐层返回结果。
LeetCode链表集锦
如风暖阳的博客
07-04 268
LeetCode链表集锦
LeetCode - 环形链表
小小太空人的博客
04-26 405
我们考虑使用追及相遇来解决。我们使用快慢指针fast和slow，初始化它们都为头结点，然后让slow一次走一步，fast一次走两步，当slow进环时，fast肯定在环里，这个时候它们开始追及。因为fast的步长是slow的两倍，所以它们之间的距离每走一次是减小1的，它们之间的距离逐渐逼近，这样slow和fast一定可以相遇。当它们距离减小到0时，即它们相遇，这个时候就可以确定链表肯定有环。
【日常系列】LeetCode《14·链表1》
qq_42889517的博客
10-07 158
你必须在 O(1) 的额外空间复杂度和 O(n) 的时间复杂度下解决这个问题。需要删除的节点 node 是 链表中的节点 ，且 不是末尾节点。链表中节点的数目范围在范围 [0, 104] 内。列表中的节点数目在范围 [0, 104] 内。链表中节点的数目在范围 [0, 500] 内。链表中节点的数目在范围 [0, 100] 内。链表中节点的数目范围是 [2, 1000]链表中节点数目在范围 [0, 300] 内。链表中节点数目在范围 [0, 300] 内。链表中节点的数目范围是 [0, 5000]
LeetCode如何构建链表和树的测试用例
dev_zyx的博客
02-14 4006
平时在刷leetcode题目中的链表和树时，难免会出现调试不方便的问题。因为习惯了IDEA中debug来进行错误分析，所以本文将实现leetcode刷题中链表和数在IDEA中的调试。 链表 直接上代码。 public static class ListNode{ int val; ListNode next; ListNode(int x) { v...
leetcode 倒序链表 两数相加
qq_44904820的博客
07-15 207
两数相加 题目: 我的解法: /** * @Description TODO * @Param [l1, l2] * @return arrays.addTwoNumbers.ListNode * @date 2020/7/14 17:21 * @author huanl * * 思路:先把他全部拿出来,拿出来的时候用字符串的append函数连接起来,后面再用reverse去反转.在把他们相加的到的 * 数转换为StringBuilder类型,然后反转,然
leetcode链表之两数相加
溪语流沙的博客
03-13 174
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《17·二叉树2》
qq_42889517的博客
10-18 263
你可以设计一个更快的算法吗？lc 236【剑指 68-2】【top100】：二叉树的最近公共祖先。lc 124【top100】：二叉树中的最大路径和。树中节点的数目范围是[0, 5 * 10^4]树中节点数目范围是 [1, 3 * 10^4]树中节点数目在范围 [2, 10^5] 内。树中节点的数目在范围 [0, 5000] 内。树中节点总数在范围 [0, 5000] 内。树中节点的数目在范围 [1, 100] 内。二叉树的节点个数的范围是 [0,1000]树中节点的数目范围是 [1, 3000]
LeetCode - 环形链表 II
小小太空人的博客
04-27 387
这里先说结论：一个指针从它们相遇的位置开始走，一个指针从head头结点处开始走，两个指针每次都走一步，它们会在环的入口处相遇。
判断链表是否为回文链表leetcode-LeetCode:leetcode日常乐趣
07-01
判断链表是否为回文链表 leetcode LeetCode leetcode dayly fun koltin解leetcode 可能时间空间复杂度不是最优的，但是能AC android开发刷题练练手 先easy后medium 最后才考虑hard 主要是锻炼开拓思维和灵活运用各种...
判断链表是否为回文链表leetcode-DailyCodingProblem:日常编码问题
07-01
判断链表是否为回文链表 leetcode /** Leetcode 样题练习 */ 无重复字符的最长子串 反转单链表。 你正在爬楼梯。 需要n步才能到达顶部。 每次您可以爬 1 步或 2 步。 你可以通过多少种不同的方式登上顶峰？ （注意：...
leetcode2-leetcode2:leetcode2
06-30
这个压缩包包含了一个名为'leetcode2-master'的项目，很可能是用户或开发者整理的一系列Python解题代码。" 【知识点详解】: 1. **LeetCode2平台**: - LeetCode2是程序员提升算法能力的重要平台，提供了多种语言的...
力扣220题详解：存在重复元素 III 的多种解法与复杂度分析
10年数据\经营分析经验，现任大厂数据分析负责人
08-21 666
本文详细解读了力扣第220题“存在重复元素 III”，通过使用滑动窗口 + 桶排序和滑动窗口 + 有序集合两种方法高效地解决了这一问题，并提供了详细的解释和模拟面试问答。希望读者通过本文的学习，能够在力扣刷题的过程中更加得心应手。
一起学习LeetCode热题100道（48/100）
weixin_53224223的博客
08-20 534
7.注意：虽然代码中包含了回溯部分（即减少当前路径和的计数并从prefixSums中删除它），但在本问题中，由于树是无环的，并且我们不需要精确跟踪每条路径，因此这部分是多余的。输入：root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22。输入：root = [10,5,-3,3,2,null,11,3,-2,null,1], targetSum = 8。1.这是主函数，接收根节点和目标和作为参数，并返回满足条件的路径数量。
Leetcode 219. 存在重复元素 II⭐️
铁马冰河入梦来
08-20 414
哈希表解决存在重复元素二问题
Leetcode面试经典150题-128.最长连续序列
最新发布
个人专长：数据结构和算法、大数据、数据库、主流框架
08-23 290
Leetcode面试经典150题-128.最长连续序列，同时也是字节面试高频题频次第15高的题，务必掌握
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值