if not head:
return head
p1 = head
lenh = 0
while p1.next:
p1 = p1.next
lenh += 1
lenh += 1
k %= lenh
if k == 0:
return head
dumpy = ListNode(0)
dumpy.next = head
p2 = head
for _ in range(lenh - k - 1):
p2 = p2.next
dumpy.next = p2.next
p1.next = head
p2.next = None
return dumpy.next
if __name__ == '__main__':
nums = "1,2,3,4,5"
k = 2
head = stringToListNode(nums)
sol = Solution()
print(listNodeToString(sol.rotateRight(head, k)))
输出：1->1->2->3->4->4
"""
from LinkList import ListNode, listNodeToString, stringToListNode
class Solution:
def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:
prehead = ListNode(-1)
prev = prehead
while l1 and l2:
if l1.val <= l2.val:
prev.next = l1
l1 = l1.next
else:
prev.next = l2
l2 = l2.next
prev = prev.next
prev.next = l1 if l1 is not None else l2
return prehead.next
if __name__ == '__main__':
input1 = "1, 2, 4"
input2 = "1, 3, 4"
l1 = stringToListNode(input1)
l2 = stringToListNode(input2)
sol = Solution()
l = sol.mergeTwoLists(l1, l2)
print(listNodeToString(l))
'''
反转一个单链表。
示例:
输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL
进阶:
你可以迭代或递归地反转链表。你能否用两种方法解决这道题？
'''
from LinkList import ListNode, stringToListNode, listNodeToString
class Solution:
def reverseList(self, head: ListNode) -> ListNode:
dumpy = ListNode(0)
first = head
while head:
head = head.next
first.next = dumpy.next
dumpy.next = first
first = head
return dumpy.next
if __name__ == '__main__':
nums = "1,2,3,4,5"
head = stringToListNode(nums)
sol = Solution()
print(listNodeToString(sol.reverseList(head)))
注意：
如果两个链表没有交点，返回 null.
在返回结果后，两个链表仍须保持原有的结构。
可假定整个链表结构中没有循环。
程序尽量满足 O(n) 时间复杂度，且仅用 O(1) 内存。
本题与主站 160 题相同：https://leetcode-cn.com/problems/intersection-of-two-linked-lists/
'''
from LinkList import ListNode, stringToListNode, listNodeToString
class Solution:
def getIntersectionNode(self, headA: ListNode,
headB: ListNode) -> ListNode:
pA, pB = headA, headB
while pA != pB:
pA = pA.next if pA else headB
pB = pB.next if pB else headA
return pA
if __name__ == '__main__':
listA = "4,1,8,4,5"
listB = "5,0,1,8,4,5"
headA = stringToListNode(listA)
headB = stringToListNode(listB)
sol = Solution()
print(listNodeToString(sol.getIntersectionNode(headA, headB)))
class Solution:
def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
dumpy = ListNode(0)
dumpy.next = l1
l = dumpy
ans = 0
while l1 or l2:
a = l1.val if l1 else 0
b = l2.val if l2 else 0
ans += a + b
ans, mod = divmod(ans, 10)
l.next = ListNode(mod)
l = l.next
if l1:
l1 = l1.next
if l2:
l2 = l2.next
if ans > 0:
l.next = ListNode(1)
return dumpy.next
if __name__ == '__main__':
nums1 = "9"
nums2 = "9"
l1 = stringToListNode(nums1)
l2 = stringToListNode(nums2)
sol = Solution()
print(listNodeToString(sol.addTwoNumbers(l1, l2)))
示例:
输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL
进阶:
你可以迭代或递归地反转链表。你能否用两种方法解决这道题？
"""
from LinkList import ListNode, stringToListNode, listNodeToString
class Solution:
def reverseList(self, head: ListNode) -> ListNode:
res = ListNode(0)
p = head
while head:
head = head.next
p.next = res.next
res.next = p
p = head
return res.next
if __name__ == '__main__':
nums = "1,2,3,4,5"
head = stringToListNode(nums)
sol = Solution()
result = sol.reverseList(head)
print(listNodeToString(result))
输入一个链表，输出该链表中倒数第k个节点。为了符合大多数人的习惯，本题从1开始计数，即链表的尾节点是倒数第1个节点。例如，一个链表有6个节点，从头节点开始，它们的值依次是1、2、3、4、5、6。这个链表的倒数第3个节点是值为4的节点。
示例：
给定一个链表: 1->2->3->4->5, 和 k = 2.
返回链表 4->5.
'''
from LinkList import ListNode, stringToListNode, listNodeToString
class Solution:
def getKthFromEnd(self, head: ListNode, k: int) -> ListNode:
fast = head
for _ in range(k):
fast = fast.next
while fast:
head = head.next
fast = fast.next
return head
if __name__ == '__main__':
nums = "1,2,3,4,5"
k = 2
head = stringToListNode(nums)
sol = Solution()
print(listNodeToString(sol.getKthFromEnd(head, k)))
给定的 n 保证是有效的。
进阶：
你能尝试使用一趟扫描实现吗？
'''
from LinkList import ListNode, stringToListNode, listNodeToString
class Solution:
def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:
dumpy = ListNode(0)
dumpy.next = head
p = dumpy
for _ in range(n):
head = head.next
while head:
head = head.next
p = p.next
p.next = p.next.next
return dumpy.next
if __name__ == '__main__':
nums = "1"
n = 1
head = stringToListNode(nums)
sol = Solution()
print(listNodeToString(sol.removeNthFromEnd(head, n)))
解释: 给定你链表中值为 1 的第三个节点，那么在调用了你的函数之后，该链表应变为 4 -> 5 -> 9.
说明：
题目保证链表中节点的值互不相同
若使用 C 或 C++ 语言，你不需要 free 或 delete 被删除的节点
'''
from LinkList import listNodeToString, stringToListNode, ListNode
class Solution:
def deleteNode(self, head: ListNode, val: int) -> ListNode:
dumpy = ListNode(0)
dumpy.next = head
p = dumpy
while p.next:
if p.next.val == val:
p.next = p.next.next
break
p = p.next
return dumpy.next
if __name__ == '__main__':
nums = '4,5,1,9'
val = 5
head = stringToListNode(nums)
sol = Solution()
print(listNodeToString(sol.deleteNode(head, val)))
注意，我们返回了一个 ListNode 类型的对象 ans，这样：
ans.val = 3, ans.next.val = 4, ans.next.next.val = 5, 以及 ans.next.next.next = NULL.
示例 2：
输入：[1,2,3,4,5,6]
输出：此列表中的结点 4 (序列化形式：[4,5,6])
由于该列表有两个中间结点，值分别为 3 和 4，我们返回第二个结点。
提示：
给定链表的结点数介于 1 和 100 之间。
'''
from LinkList import ListNode, stringToListNode, listNodeToString
class Solution:
def middleNode(self, head: ListNode) -> ListNode:
slow, fast = head, head
while fast and fast.next:
slow = slow.next
fast = fast.next.next
return slow
if __name__ == '__main__':
nums = "1,2,3,4,5"
head = stringToListNode(nums)
sol = Solution()
print(listNodeToString(sol.middleNode(head)))
return l2
if not l2:
return l1
if l1.val < l2.val:
l1.next = self.merge(l1.next, l2)
return l1
l2.next = self.merge(l1, l2.next)
return l2
def mergeKLists(self, lists: List[ListNode]) -> ListNode:
len_ = len(lists)
if len_ < 1:
return None
if len_ == 1:
return lists[0]
mid = len_ // 2
left = self.mergeKLists(lists[:mid])
right = self.mergeKLists(lists[mid:])
return self.merge(left, right)
if __name__ == '__main__':
lists = [
stringToListNode("1,4,5"),
stringToListNode("1,3,4"),
stringToListNode("2,6")
]
sol = Solution()
print(listNodeToString(sol.mergeKLists(lists)))
