给你一个链表,删除链表的倒数第 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],应该输出[ ]
将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
输入: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
给定一个链表,返回链表开始入环的第一个节点。 如果链表无环,则返回 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
给你两个单链表的头节点 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
给你一个链表的头节点 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
输入一个链表的头节点,从尾到头反过来返回每个节点的值(用数组返回)
# 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]
给定一个链表: 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
输入: 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
给定一个链表,两两交换其中相邻的节点,并返回交换后的链表。
你不能只是单纯的改变节点内部的值,而是需要实际的进行节点交换。
# 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