Leetcode刷题总结——链表

最新推荐文章于 2023-03-04 15:24:46 发布

skytian_wang

最新推荐文章于 2023-03-04 15:24:46 发布

阅读量232

点赞数

原文链接：https://leetcode-cn.com/

版权

19. 删除链表的倒数第 N 个结点

给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

正确解答：

# 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: ListNode, n: int) -> ListNode:
        pre=ListNode(0)
        pre.next=head
        former,latter=pre,pre
        for _ in range(n+1):
            former=former.next
        while former:
            former,latter=former.next,latter.next
        latter.next=latter.next.next
        return pre.next

错误解答·1：

# 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: ListNode, n: int) -> ListNode:
        former,latter=head,head
        for _ in range(n+1):
            former=former.next
        while former:
            former,latter=former.next,latter.next
        latter.next=latter.next.next
        return head

当输入

输入：[1] 1

AttributeError: 'NoneType' object has no attribute 'next'
former=former.next
Line 10 in removeNthFromEnd (Solution.py)
ret = Solution().removeNthFromEnd(param_1, param_2)
Line 42 in _driver (Solution.py)
_driver()
Line 53 in <module> (Solution.py)
错误解答2:

# 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: ListNode, n: int) -> ListNode:
        pre=ListNode(0)
        pre.next=head
        former,latter=pre,pre
        for _ in range(n+1):
            former=former.next
        while former:
            former,latter=former.next,latter.next
        latter.next=latter.next.next
        return head

输入：[1] 1，输出[1]，应该输出[ ]

21. 合并两个有序链表

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

输入：l1 = [1,2,4], l2 = [1,3,4]
输出：[1,1,2,3,4,4]
输入：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, l1: ListNode, l2: ListNode) -> ListNode:
        pre=ListNode(-1)
        res=pre
        while l1 and l2:
            if l1.val>l2.val:
                res.next,l2=l2,l2.next  
            else:res.next,l1= l1,l1.next
            res=res.next
        res.next=l2 if l2 is not None  else l1
        return  pre.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, l1: ListNode, l2: ListNode) -> ListNode:
        pre=ListNode(0)
        res=pre
        while l1 and l2:
            if l1.val>l2.val:
                res.next,l2=l2,l2.next  
            else:
                res.next,l1= l1,l1.next
        if not l1:res.next=l2
        else:res.next=l1
        return  pre.next

142. 环形链表 II

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

为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意，pos 仅仅是用于标识环的情况，并不会作为参数传递到函数中。

说明：不允许修改给定的链表。

进阶：

你是否可以使用 O(1) 空间解决此题？

判断fast和fast.next

第一次判断相遇，第二次判断相遇的位置

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

class Solution:
    def detectCycle(self, head: ListNode) -> ListNode:
        fast,low=head,head
        while True:
            if not fast or not fast.next:return 
            fast=fast.next.next
            low=low.next
            if fast==low:break
        fast=head
        while fast!=low:
            low=low.next
            fast=fast.next
        return fast

160. 相交链表

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

# 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:
        A, B = headA, headB
        while A != B:
            A = A.next if A else headB
            B = B.next if B else headA
        return A

判断a.next会超时，

# 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:
        A, B = headA, headB
        while A != B:
            A = A.next if A.next else headB
            B = B.next if B.next else headA
        return A

203. 移除链表元素

给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。

# 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: ListNode, val: int) -> ListNode:
        dun=ListNode(0)
        dun.next=head
        pre=dun
        while pre.next:
            if pre.next.val!=val:
                pre=pre.next
            else:
                pre.next=pre.next.next
        return dun.next

剑指 Offer 06. 从尾到头打印链表

输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None
class Solution:
    def reversePrint(self, head: ListNode) -> List[int]:
        res=[]
        while head is not None:
            res.append(head.val)
            head=head.next
        return res[::-1]

剑指 Offer 22. 链表中倒数第k个节点

给定一个链表: 1->2->3->4->5, 和 k = 2.

返回链表 4->5.

输入一个链表，输出该链表中倒数第k个节点。为了符合大多数人的习惯，本题从1开始计数，即链表的尾节点是倒数第1个节点。

例如，一个链表有 6 个节点，从头节点开始，它们的值依次是 1、2、3、4、5、6。这个链表的倒数第 3 个节点是值为 4 的节点。

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

class Solution:
    def getKthFromEnd(self, head: ListNode, k: int) -> ListNode:
        former,latter=head,head
        for _ in range (k):
            former= former.next
        while former:
            latter,former=latter.next,former.next
        return latter

剑指 Offer 24. 反转链表

输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL

好理解的双指针
定义两个指针： prepre 和 curcur ；prepre 在前 curcur 在后。
每次让 prepre 的 nextnext 指向 curcur ，实现一次局部反转
局部反转完成之后， prepre 和 curcur 同时往前移动一个位置
循环上述过程，直至 prepre 到达链表尾部

# 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:
        cur,pre=None,head
        while pre:
            res=pre.next
            pre.next=cur
            cur=pre
            pre=res
        return cur

class Solution:
    def reverseList(self, head: ListNode) -> ListNode:
        pre,cur=None,head
        while cur:
            cur.next,cur,pre=pre,cur.next,cur
        return pre

24. 两两交换链表中的节点

给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。

你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

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

class Solution:
    def hasCycle(self, head: ListNode) -> bool:
        fast,slow=head,head
        while fast and slow and fast.next:
            fast,slow=fast.next.next,slow.next
            if fast is slow:
                return True
        return False