leetcode链表题

最新推荐文章于 2022-01-02 23:05:39 发布
最新推荐文章于 2022-01-02 23:05:39 发布
阅读量171 收藏
点赞数
分类专栏： 数据结构与基础算法 文章标签： 链表 leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38119106/article/details/107879398
版权

目录

2020/8/8

160链表相交

# 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:
        curA=headA
        curB=headB
        #计算长度差
        n=0
        while(curA):
            n+=1
            curA=curA.next
        while(curB):
            n-=1
            curB=curB.next
        if(curA!=curB):
            return None        
        #长链表先走【长度差】
        curA=headA if n>0 else headB
        curB=headB if n>0 else headA
        n=abs(n)
        while(n>0):
            n-=1
            curA=curA.next
        while(curA!=curB):
            curA=curA.next
            curB=curB.next
        return curA

# 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:
        cur1=headA
        cur2=headB
        while(cur1 != cur2):
            cur1=cur1.next if cur1 else headB
            cur2=cur2.next if cur2 else headA
        return cur1

206翻转链表

# 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:
        pre=None
        cur=head
        while(cur):
            temp=ListNode(cur.val)
            temp.next=pre
            pre=temp
            cur=cur.next
        return pre

# 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:
        pre=None
        while(head):
            temp=head.next
            head.next=pre
            pre=head
            head=temp
        return pre

21合并两个有序链表

迭代

# 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, l1: ListNode, l2: ListNode) -> ListNode:
        #选择当前l1 l2中较小的元素
        pre=ListNode(None)
        cur=pre
        while(l1 and l2):
            if(l1.val<l2.val):
                cur.next=l1
                l1=l1.next
            else:
                cur.next=l2
                l2=l2.next
            cur=cur.next
        cur.next=l1 if l1 else l2
        pre=pre.next
        return pre

83 删除排序链表中重复值

暴力解法

class Solution:
    def deleteDuplicates(self, head: ListNode) -> ListNode:
        #遍历 遇到重复 就指向其下一个      
        if(not head):
            return None
        cur=head
        while(cur and cur.next):
            #当前是重复值
            if(cur.val==cur.next.val):
                cur.next=cur.next.next
            #当前不重复
            else:
                cur=cur.next
        return head

2020/8/9

19删除链表倒数第N个节点

哑节点为了两种情况：
①一个节点 ②node_num==n

class Solution:
    def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:
        node_nums=0
        cur=head
        while(cur):
            node_nums+=1
            cur=cur.next
        cur=head
        #为了包含这两种情况 可以增加哑节点
        if(node_nums==1):
            return None
        if(node_nums==n):
            return head.next
        #以上
        for i in range(0,node_nums-n-1):
            cur=cur.next
        cur.next=cur.next.next
        return head
        

class Solution:
    def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:
        node_nums=0
        prehead=ListNode(None)
        prehead.next=head
        cur=head
        while(cur):
            node_nums+=1
            cur=cur.next
        cur=prehead
        for i in range(0,node_nums-n):
            cur=cur.next
        cur.next=cur.next.next
        return prehead.next

双指针 一次遍历

class Solution:
    def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:

        pre=ListNode(0)
        pre.next=head
        cur1=pre
        cur2=pre
        while(cur2.next):
            if(n>0):
                cur2=cur2.next
                n-=1
            else:
                cur2=cur2.next
                cur1=cur1.next
        cur1.next=cur1.next.next
        return pre.next

2020/9/10

24两两交换节点

class Solution:
    def swapPairs(self, head: ListNode) -> ListNode:
        pre=ListNode(-1)
        pre.next=head
        cur=pre
        while(cur.next and cur.next.next):
            #交换cur.next cur.next.next
            p1=cur.next
            p2=p1.next
            p1.next=p2.next
            p2.next=p1
            cur.next=p2
            cur=cur.next.next
        return pre.next

445两数相加II

用栈保存两组数 用a1.pop a2.pop更方便写

class Solution:
    def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
        result=None
        a1,a2=[],[]
        while(l1):
            a1.append(l1.val)
            l1=l1.next
        while(l2):
            a2.append(l2.val)
            l2=l2.next
        t=0 #进位 1或0
        len1,len2=len(a1),len(a2)
        if(len1<len2):
            a1,a2=a2,a1
            len1,len2=len2,len1
        #a1长位 a2短位 或者位数相同
        for i in range(-1,-1-len1,-1):
            singleSum=a1[i]+a2[i]+t if -i<=len2 else a1[i]+t
            temp=ListNode(singleSum%10)
            temp.next=result
            result=temp
            # print(singleSum)
            # print(result)
            if(singleSum>=10):
                t=1
            else:
                t=0

        if(t==1):
            temp=ListNode(1)
            temp.next=result
            result=temp
        return result

234回文链表

class Solution:
    def isPalindrome(self, head: ListNode) -> bool:
        #两个字符串
        a=[]
        while(head):
            a.append(head.val)
            head=head.next
        return a==a[::-1]

递归可以使得空间复杂度o(1) 或者切割成两半 反转一半 判断是否相等

725分割链表

class Solution:
    def splitListToParts(self, root: ListNode, k: int) -> List[ListNode]:
        #每份应当是num/k 前num%k个数应该+1 k>num时后面num-k份 null
        #获取节点数
        num=0
        result=[]
        cur=root
        while(cur):
            num+=1
            cur=cur.next
        #计算份数 平均节点数
        singleNum=int(num/k)
        moreNum=num%k
        #给每一份 按照 节点数 得到结果
        cur=root
        for i in range(0,k):
            iNum=singleNum+1 if i<moreNum else singleNum

            if(iNum==0):
                result.append(None)
            else:
                if(iNum>=2):
                    for j in range(0,iNum-1):
                        cur=cur.next
                temp=cur.next
                cur.next=None
                result.append(root)
                root=temp
                cur=root

        return result

class Solution:
    def splitListToParts(self, root: ListNode, k: int) -> List[ListNode]:
        #每份应当是num/k 前num%k个数应该+1 k>num时后面num-k份 null
        #获取节点数
        num=0
        result=[]
        cur=root
        while(cur):
            num+=1
            cur=cur.next
        #计算份数 平均节点数
        singleNum=int(num/k)
        moreNum=num%k
        #给每一份 按照 节点数 得到结果
        cur=root
        for i in range(0,k):
            iNum=singleNum+1 if i<moreNum else singleNum

            if(iNum==0):
                result.append(None)
            else:
                for j in range(0,iNum-1):
                    if(cur):
                        cur=cur.next
                temp=cur.next
                cur.next=None
                result.append(root)
                root=temp
                cur=root

        return result

328链表元素按奇偶聚集

遍历 是奇数点 连到h1 是偶数点 连到h2
h1的末尾连h2开头(cur1连cur2.next)
五个指针

class Solution:
    def oddEvenList(self, head: ListNode) -> ListNode:
        cur=head
        h1,h2=ListNode(-1),ListNode(-1)
        cur1,cur2=h1,h2
        flag=True#奇数
        while(cur):
            temp=cur.next
            cur.next=None
            if(flag):
                cur1.next=cur
                cur1=cur1.next
            else:
                cur2.next=cur
                cur2=cur2.next
            flag=not flag
            cur=temp

        cur1.next=h2.next
        return h1.next

下面是官方 4个指针

class Solution:
    def oddEvenList(self, head: ListNode) -> ListNode:
        while(head==None or head.next==None):
            return head
        cur1=head#奇：头head 尾cur1
        h2=head.next#偶:头h2 尾cur2
        cur2=h2
        while(cur1.next and cur2.next):
            cur1.next=cur2.next
            cur2.next=cur2.next.next
            cur1,cur2=cur1.next,cur2.next
        cur1.next=h2
        return head

2021/5/14

23. 合并K个升序链表

顺序合并很慢

# 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[ListNode]) -> ListNode:
        p1=None
        result=None
        for p2 in lists:
            result=self.merge2List(p1,p2)
            p1=result

        return result
        

    def merge2List(self,l1,l2):
        cur=ListNode(-1)
        pre=cur
        while(l1 and l2):
            if(l1.val<=l2.val):
                pre.next=l1
                l1=l1.next
            else:
                pre.next=l2
                l2=l2.next
            pre=pre.next
        
        if(l1):
            pre.next=l1
        if(l2):
            pre.next=l2
        return cur.next

这题关键是分治

# 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[ListNode]) -> ListNode:
        return self.part(lists,0,len(lists)-1)

    # 两两合并 返回l r位置合并后的一个链表
    def part(self,lists,l,r):
        # print('part:l{},r{}'.format(l,r))
        if(l==r):
            return lists[l]
        if(l>r):
            return None
        mid=(l+r)//2
        # 传参两个链表 返回排序合并的链表
        return self.merge2List(self.part(lists,l,mid),self.part(lists,mid+1,r))
        

    def merge2List(self,l1,l2):
        cur=ListNode(-1)
        pre=cur
        while(l1 and l2):
            if(l1.val<=l2.val):
                cur.next=l1
                l1=l1.next
            else:
                cur.next=l2
                l2=l2.next
            cur=cur.next
        
        if(l1):
            cur.next=l1
        if(l2):
            cur.next=l2
        return pre.next

61. 旋转链表

双指针 注意边界

# 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: ListNode, k: int) -> ListNode:
        if((not head) or (k==0) or (head and not head.next)):
            return head

        step=1
        tmp=head
        while(tmp and tmp.next):
            tmp=tmp.next
            step+=1
        k=k%step
        if(k==0):
            return head

        # 找到倒数第k个位置
        # [1,2,3,4,5] k=2,快慢指针找到3
        # 快慢指针找到tmp tmp.next就是第K个
        fast=ListNode(-1)
        slow=ListNode(-1)
        fast.next=head
        slow.next=head
        left=slow

        # 快的先走k步 因为k<len 所以直接走就好了
        for i in range(k):
            fast=fast.next
        
        while(fast and fast.next):
            fast=fast.next
            slow=slow.next

        # fast是最后一个元素（非None）
        # slow在3 fast在5
        # print(slow) # 3-4-5
        # print(fast) # 5

        result=slow.next # slow不可能是最后一个
        resultCur=slow.next
        while(resultCur and resultCur.next):
            resultCur=resultCur.next

        # while(slow and slow.next):
        #     slow=slow.next
        slow.next=None
        resultCur.next=left.next
        
        return result

看了题解 发现先连成环 再断开 会很方便 代码量少很多

# 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: ListNode, k: int) -> ListNode:
        if((not head) or (k==0) or (head and not head.next)):
            return head

        # [1,2,3,4,5] k=2

        step=1
        cur=head
        while(cur.next):
            cur=cur.next
            step+=1
        k=k%step
        # 此时cur在5
        if(k==0):
            return head

        # 成环 找断开位置 找到3 (len-k)即可
        cur.next=head 
        for i in range(step-k):
            cur=cur.next

        result=cur.next
        cur.next=None
        
        return result

2021/5/16

92. 反转链表 II

这题真心不太懂 按照自己的思路还可以

class Solution:
    def reverseBetween(self, head: ListNode, left: int, right: int) -> ListNode:
        if(left==right or not head or not head.next):
            return head

        dummy=ListNode(-1)
        dummy.next=head

        p1=dummy
        # p1走到left前一个位置
        for _ in range(left-1):
            p1=p1.next

        # p2=[left-----right-last]
        p2=p1.next
        p3=p2
        # p3走到right位置
        for _ in range(right-left+1):
            p3=p3.next

        # 现在 p1在left-1；p2是[left---right--last];p3是[last]
        print(p1)
        print(p2)
        print(p3)

        pre=p3 # pre是p2的头 后面就变成p2的尾 后面连p3
        for _ in range(right-left+1):
            nxt=p2.next
            p2.next=pre
            pre=p2
            p2=nxt        


        p1.next=pre
        # p2.next=p3

        return dummy.next

官方题解方法一看不懂 关键是弄明白那个变量怎么修改链表 哪些变量是关联的 变量1变会不会影响变量2

2021/5/18

817. 链表组件

这题完全是题目描述不清晰。。

class Solution:
    def numComponents(self, head: ListNode, nums: List[int]) -> int:
        if(not head):
            return 0
        a=[] # 临时存储序列
        nums=set(nums)
        ret=0

        while(head):
            # 如果连续
            if(head.val in nums):
                a.append(head.val)
                # print(a)
                #idx=nums[idx::].index(head.val)+idx+1 # 更新开始搜索的下一个idx
                #nums[idx-1]=-1 # 使用过的G位置数字置为-1
                #nums.remove(head.val)
            else:
                # 说明断开连续了 重置
                if(len(a)>0):
                    a=[] 
                    ret+=1

            head=head.next

        ret=ret+1 if len(a)>0 else ret
        return ret

143. 重排链表

直接用数组存储节点值

class Solution:
    def reorderList(self, head: ListNode) -> None:
        """
        Do not return anything, modify head in-place instead.
        """
        if(not head or not head.next):
            return
        a=[]
        cur=head
        while(cur):
            a.append(cur.val)
            cur=cur.next
        # [1,2,3,4,5]
        left=0
        right=len(a)-1
        cur=head
        while(left<=right):
            if(left==right):
                cur.next=ListNode(a[left])
            else:
                if(left>0):
                    cur.next=ListNode(a[left])
                    cur=cur.next
                cur.next=ListNode(a[right])
                cur=cur.next
            left+=1
            right-=1

为了节约空间，可以：

  • 找中点
  • 中点.next做右边；翻转右边
  • 左右间隔相差
# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def reorderList(self, head: ListNode) -> None:
        """
        Do not return anything, modify head in-place instead.
        """
        if(not head or not head.next):
            return
        # 找Mid作为right
        right=head
        fast=head
        while(fast and fast.next):
            fast=fast.next.next
            right=right.next
        # 断开左右
        l2=right.next
        right.next=None
        # 翻转右边
        l2_reverse=None
        while(l2):
            nxt=l2.next
            l2.next=l2_reverse
            l2_reverse=l2
            l2=nxt
        # print(head)
        # print(l2_reverse)
        # 合并左右
        cur=head # head一定大于等于l2_reverse
        while(cur and l2_reverse):
            nxt=l2_reverse.next
            # 从l2中插入到l1中
            l2_reverse.next=cur.next
            cur.next=l2_reverse
            l2_reverse=nxt
            cur=cur.next.next

82. 删除排序链表中的重复元素 II

这题想明白了 就是写的很别扭

  • 用dummy
  • 用node.next判断值
class Solution:
    def deleteDuplicates(self, head: ListNode) -> ListNode:
        if(not head or not head.next):
            return head
        # 快慢指针
        dummy=ListNode(-1)
        dummy.next=head
        slow=dummy
        fast=dummy.next
        flag=False
        while(fast and fast.next):
            # 当fast相等于slow的下一个时
            if(fast.next.val==slow.next.val):
                flag=True
                fast=fast.next
            else:
                # 不等的时候 falg=True说明fast的pre是相等的要删除
                if(flag):
                    slow.next=fast.next
                    fast=fast.next
                    flag=False
                else:
                    slow=slow.next
                    fast=fast.next
        # 排除[2,1,1]情况 因为fast到了最后1的时候 fast.next=None 跳出循环
        if(flag):
            slow.next=fast.next        

        return dummy.next

还是题解简单

class Solution:
    def deleteDuplicates(self, head: ListNode) -> ListNode:
        if(not head or not head.next):
            return head
        # 快慢指针
        dummy=ListNode(-1)
        dummy.next=head
        cur=dummy
        while(cur.next and cur.next.next):
            # 遇到相等 就一直往下找
            if(cur.next.val==cur.next.next.val):
                x=cur.next.val
                while(cur.next and cur.next.val==x):
                    cur.next=cur.next.next
            else:
                cur=cur.next

        return dummy.next

2021/9/24

430. 扁平化多级双向链表

这题的核心是怎么更新cur的last

  • 当cur.child时，last=cur.child.last
  • 当cur.next时，lst=cur.next

刚开始一直不理解这个last，刚开始是写的注释掉的2写法，其实也可以但是会慢一点，主要就是搞清楚当node是第一个child时，其nxt中出现了child，那么node的tail怎么计算：

  • 首先，node_nxt中出现一个child时,cur_node_tail = dfs(node_child)
  • 核心在这，因为要遍历node这一链路，所以会继续更新 cur_node_tail；当node_child遍历完回来，node还有nxt时，还会往下遍历，如果nxt没有child,tail又会更新为nxt；所以就完成了tail的更新
class Solution:
    def flatten(self, head: 'Node') -> 'Node':
        if(not head):
            return head

        self.dfs(head)
        return head

    # head是child时 返回这条链路最后一个node
    def dfs(self,head):
        tail=head
        cur=tail

        while(cur):
            nxt=cur.next
            # cur有child时
            if(cur.child):
                # 1 更新head的tail
                tail=self.dfs(cur.child)
                print(f'cur:{cur.child.val},tail:{tail.val}')
                # 更新child连接
                cur.next=cur.child
                cur.next.prev=cur
                cur.child=None
                # 更新tail.next
                if(nxt):
                    tail.next=nxt
                    nxt.prev=tail
            else:
                tail=cur
            # # 2 当前head是child节点
            # # 2 所以当前head的tail 如果有child tail=dfs(child)；紧接着如果nxt tail=nxt
            # if(nxt):
            #     tail=nxt

            cur=nxt

        return tail

class Solution:
    def flatten(self, head: 'Node') -> 'Node':
        if(not head):
            return head

        self.dfs(head)
        return head

                
    # 将child这一链路修改 返回这一路的last
    def dfs(self,node):
        cur=node
        tail=node
        while(cur):
            nxt=cur.next
            if(cur.child):
                child_t=self.dfs(cur.child)
                # 第一步 cur-next
                cur.next=cur.child
                cur.child.prev=cur
                cur.child=None   
                # 第二步 last-nxt
                if(nxt):
                    child_t.next=nxt
                    nxt.prev=child_t
                
                # 注意这个tail的更新位置
                tail=child_t
            else:
                tail=cur

            cur=nxt                         

        return tail

114. 二叉树展开为链表

注意tail的位置

class Solution:
    def flatten(self, root: TreeNode) -> None:
        """
        Do not return anything, modify root in-place instead.
        """
        if(not root):
            return root
        self.dfs(root)
        return root

    # 当root是left时 返回left链路的最后一个node
    def dfs(self,root):
        cur=root    
        tail=root
        while(cur):
            nxt=cur.right
            if(cur.left):
                # left节点的链路最后一个node
                left_tail=self.dfs(cur.left)
                # print(f'cur{cur.val},left_tail{left_tail.val},right{nxt.val}')
                left_tail.right=nxt
                cur.right=cur.left
                cur.left=None
                tail=left_tail

            # right存在时
            cur=nxt
            if(nxt):
                tail=nxt


        return tail
Dive_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
力扣练习——5 分隔链表
qq_43403657的博客
07-03 173
分隔链表
LeetCode 725 (Split Linked List in Parts)
zlzl8885的博客
11-14 822
leetcode
split直接转换为List集合的方法
cdc8596的博客
04-24 7846
通过 var sNumbers = "1,2,3,4,5,6" 转换为Int泛型型的list List<int> numbers = sNumbers.Split(new char[]{','},StringSp...
【LeetCode】725. Split Linked List in Parts 解题报告（Python & C++）
负雪明烛
03-13 1382
【LeetCode】725. Split Linked List in Parts 解题报告（Python） 标签： LeetCode 题目地址：https://leetcode.com/problems/split-linked-list-in-parts/description/ 题目描述： Given a (singly) linked list with head node...
725. Split Linked List in Parts
分享人工智能学习心得与实践经验，探讨应用场景，见证变革与进步
12-05 654
题目Given a (singly) linked list with head node root, write a function to split the linked list into k consecutive linked list “parts”.The length of each part should be as equal as possible: no two parts
LeetCode 链表的中间结点
12-21
题目来源：https://leetcode-cn.com/problems/middle-of-the-linked-list 题目 给定一个带有头结点 head 的非空单链表，返回链表的中间结点。 如果有两个中间结点，则返回第二个中间结点。 示例 1： 输入：[1,2,3,4...
Leetcode 反转链表.js
最新发布
02-21
LeetCode 206的题目是“反转链表”（Reverse Linked List），它要求将一个单链表的所有节点反转，并返回反转后链表的头节点。这是一个基础但非常重要的链表操作问题，它不仅考察了对链表数据结构的理解，还涉及到了...
Leetcode 移除链表元素.go
02-21
LeetCode 203的题目是“移除链表元素”，要求从一个链表中删除所有值等于给定值val的节点，并返回新链表的头节点。这个问题考验的是对链表数据结构的理解和操作能力，包括如何遍历链表、如何处理边界条件（如头节点...
leetcode-链表笔记
02-06
leetcode-链表笔记
leetcode算法题-链表操作（两数相加）
12-20
leetcode 算法题： 两数相加 给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。 如果，我们将这两个数相加起来，则会返回一个新...
【LeetCode】725. Split Linked List in Parts
寒沨的博客
05-09 296
Problem：Given a (singly) linked list with head node root, write a function to split the linked list into k consecutive linked list "parts".The length of each part should be as equal as possible: no tw...
数据结构与算法--链表
gg13213的博客
10-05 130
链表链表移除链表元素反转链表 链表 单链表：链表是指通过指针串联在一起的线性结构，每一个节点由两部分组成，一个是数据域、一个是指针域（存放指向下一个节点指针），最后一个节点的指针域指向null（空指针）。 链表的入口节点称为链表的头节点，即head。 双链表：每一个节点有两个指针域，一个指向下一个节点，另一个指向上一个节点。 双链表既可以向前查询也可以向后查询。 循环列表：链表首尾相连。 链表的存储方式： 链表在内存中不是连续分布的，链表通过指针域的指针链接在内存中的各个节点。即链表散乱分布在内存中的某地址
面试题 02.07. 链表相交
厚积而薄发
01-02 547
class Solution: def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode: """ 根据快慢法则，走的快的一定会追上走得慢的。 在这道题里，有的链表短，他走完了就去走另一条链表，我们可以理解为走的快的指针。 那么，只要其中一个链表走完了，就去走另一条链表的路。如果有交点，他们最终一定会在同一个 位置相遇.
链表的应用（数据结构实验题）
Darcy的博客
05-20 2194
题目：求相邻k个节点数值之和最大的第一节点 输入数据（设为整型）建立单链表，并求相邻k个节点data值之和为最大的第一节点。例如输入k = 2，数据为2 64 7 3 #（#为结束符），建立下面链表，运行结果输出（序号3，data值4）：一、 问题分析与算法思路 首先将问题分解为3个步骤：数据输入—>数据处理—>结果输出 题目给定使用链表来保存整型数据，并且只需要求某个节点
【LeetCode-链表】相交链表
lucky_kai的博客
04-20 141
Link:相交链表 语言：Python 难度：简单 描述：找到两个单链表的重合链。比如： Node_A = [4,1,8,4,5]; Node__B = [5,0,1,8,4,5],则这两个链表的起始节点为8，重合链为[8,4,5]。 Node_A = [4,1,7,2,1]; Node__B = [5,0,1,8,4,5],则这两个链表的起始节点为null，不存在。 方法一： 将其中一个No...
Python实现常见的链表问题
Matrix_cc的博客
03-27 720
1.环形列表 class Solution: def hasCycle(self, head: ListNode) -> bool: if not head or not head.next : return False slow = head fast = head while (fas...
有关链表基本操作三题
weixin_30500473的博客
07-11 693
因为觉得C语言老师讲链表讲的太匆忙了，况且PPT太乱太杂，看不懂 因此特地重写了次这周三上机有关链表操作的三题。（所写题目默认已排序，不考虑排序） 问题 A: 在单链表中按学号查成绩 时间限制:1 Sec内存限制:128 MB 提交:62解决:43 [提交][状态][讨论版] 题目描述 写一个建立单链表的函数，设链表的表元素包含学号、姓名、一门课的成绩，写一个按...
链表相交的一系列问题python实现
桔梗的眼泪博客
06-18 245
【题目】 　　在本题中，单链表可能有环，也可能没环。给定两个单链表的头节点head1和head2，这两个单链表可能相交，也可能不相交。请实现一个函数，如果两个链表相交，请返回相交的第一个节点；如果不相交，返回null即可。 要求，时间复杂度O(N+M)，空间复杂度O(1)。 【基本思路】 　　该问题可以分解成三个子问题： 　　 　　问题一：如何判断一个链表是否有环，如果有的话返回第一个...
链表常见面试题
weixin_45785104的博客
10-25 207
注：本文章练习题来自牛客和LeetCode，分享的是自己的练习总结 1.给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。1.先不考虑头结点，因为优先考虑头结点值会产生循环处理较为复杂 2.先进行处理后面的普通的结点，如果该结点的值与val相等，则删除，若不相等则继续处理下一个结点，直到处理完所有的结点 3.再处理头结点 /** * Definition for singly-linked list....
rust leetcode 链表
05-10
例如，针对 LeetCode 中的链表题目，我们可以用 Rust 语言来编写解法，例如，反转链表，合并两个有序链表，删除链表中的重复元素等等，这样可以更好地熟悉 Rust 语言的使用和链表的操作，提高算法和编程能力。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值