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))
'''
实现一种算法，删除单向链表中间的某个节点（即不是第一个或最后一个节点），假定你只能访问该节点。
示例：
输入：单向链表a->b->c->d->e->f中的节点c
结果：不返回任何数据，但该链表变为a->b->d->e->f
'''
from LinkList import ListNode, stringToListNode
class Solution:
def deleteNode(self, node):
"""
:type node: ListNode
:rtype: void Do not return anything, modify node in-place instead.
"""
node.next = node.next.next
node.val = node.next.val
if __name__ == '__main__':
str_ = "a,b,c,d,e,f"
node = stringToListNode(str_)
sol = Solution()
sol.deleteNode(node)
注意：
如果两个链表没有交点，返回 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)))
p = root
for _ in range(div):
root = root.next
# p到root之间的结点，即为一段
res[i] = p
p = root
root = root.next
p.next = None
i += 1
# 长度正常的结点
while i < k:
p = root
if div == 0:
break
for _ in range(div - 1):
root = root.next
res[i] = p
p = root
root = root.next
p.next = None
i += 1
return res
if __name__ == '__main__':
nums = "1,2,3"
k = 5
root = stringToListNode(nums)
sol = Solution()
sol.splitListToParts(root, k)
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)))
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)))
