def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
"""
:type l1: ListNode
:type l2: ListNode
:rtype: ListNode
"""
carry = 0
# create a head node which does not contains value
root = n = ListNode(0)
while l1 or l2 or carry:
v1 = 0
v2 = 0
if l1:
v1 = l1.val
l1 = l1.next
if l2:
v2 = l2.val
l2 = l2.next
carry, val = divmod(v1 + v2 + carry, 10)
n.next = ListNode(val)
n = n.next
return root.next
def main():
sln = Solution()
node1 = ListNode(1)
node2 = ListNode(2)
node3 = ListNode(3)
node1.next = node2
node2.next = node3
print(sln.reverseList(node1).show())
def fastest(self, l1: ListNode, l2: ListNode) -> ListNode:
tmp = 0
res = ans = ListNode(None)
while l1 or l2 or tmp:
tmp += (l1.val if l1 else 0) + (l2.val if l2 else 0)
res.next = ListNode(tmp % 10)
tmp //= 10
res = res.next
l1 = l1.next if l1 else None
l2 = l2.next if l2 else None
return ans.next
def insertion_sort_list(head):
cur = parent = ListNode(None)
while head:
while cur.next and cur.next.val < head.val:
cur = cur.next
cur.next, head.next, head = head, cur.next, head.next
cur = parent
return cur.next
def toList(self, array):
# 将数组转换为链表
if len(array) == 0:
return
nodes = [ListNode(a) for a in array]
cur = nodes[0]
for i in range(1, len(nodes)):
cur.next = nodes[i]
cur = nodes[i]
return nodes[0]
def middleNode(self, head: ListNode) -> ListNode:
fast = slow = ListNode(None)
fast.next = head
slow.next = head
while fast is not None:
slow = slow.next
fast = fast.next
if fast is None:
break
fast = fast.next
return slow
def swapPairs(self, head: ListNode) -> ListNode:
dummy = pre = ListNode(0)
pre.next = head
while pre.next and pre.next.next:
current = pre.next
current_next = pre.next.next
pre.next, current.next, current_next.next = current_next, current_next.next, current
pre = current
return dummy.next
def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:
dummy = ListNode(0)
dummy.next = head
first = dummy
second = dummy
for i in range(n + 1):
first = first.next
while first is not None:
first = first.next
second = second.next
second.next = second.next.next
return dummy.next
def reverseKGroup(self, head: ListNode, k: int) -> ListNode:
result = t = ListNode(0, head)
temp = head
k_list = list()
while temp:
k_list.append(temp)
temp = temp.next
if len(k_list) == k:
h_node = k_list[-1].next
for i in range(1, k):
k_list[i].next = k_list[i - 1]
k_list[0].next = h_node
t.next = k_list[-1]
t = k_list[0]
k_list = list()
return result.next
def mergeKLists(self, lists):
"""
:type lists: List[ListNode]
:rtype: ListNode
"""
nodes = []
for l in lists:
while l:
nodes.append(l)
l = l.next
nodes = sorted(nodes, key=lambda x: x.val)
dummy = head = ListNode(0)
for node in nodes:
head.next = node
head = head.next
return dummy.next
def main():
head = ListNode(1)
node1 = ListNode(2)
node2 = ListNode(3)
node3 = ListNode(4)
node4 = ListNode(5)
node5 = ListNode(6)
node6 = ListNode(7)
# head.next = node1
node1.next = node2
node2.next = node3
node3.next = node4
node4.next = node5
node5.next = node6
sln = Solution()
print(sln.removeNthFromEnd(head, 1).show())
def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
head = l1
d, m = divmod(l1.val + l2.val, 10)
head.val = m
while all([l1.next, l2.next]):
l1 = l1.next
l2 = l2.next
l1.val += d
d, m = divmod(l1.val + l2.val, 10)
l1.val = m
l1.next = l1.next if l1.next else l2.next
while l1.next and d:
l1 = l1.next
d, m = divmod(l1.val + d, 10)
l1.val = m
if d:
l1.next = ListNode(val=d)
return head
def best(self, head: ListNode, n: int) -> ListNode:
"""
双指针，前指针超前后指针n+1,删除后指针的next
:param head:
:param n:
:return:
"""
dummy = ListNode(0, head)
first = head
second = dummy
for i in range(n):
first = first.next
while first:
first = first.next
second = second.next
second.next = second.next.next
return dummy.next
def mergeKLists(self, lists: List[ListNode]) -> ListNode:
from queue import PriorityQueue
head = dummy = ListNode(0)
count = 0
q = PriorityQueue()
for i in range(len(lists)):
temp = lists[i]
while temp:
q.put((temp.val, count, temp))
temp = temp.next
count += 1
while not q.empty():
dummy.next = q.get()[2]
dummy = dummy.next
return head.next
def mergeKLists(self, lists: List[ListNode]) -> ListNode:
head = dummy = ListNode(0)
while True:
min_val = 2147483647
min_index = None
to_break = True
for index in range(len(lists)):
if lists[index]:
if lists[index].val < min_val:
min_index = index
min_val = lists[index].val
to_break = False
if to_break:
break
dummy.next = lists[min_index]
dummy = dummy.next
lists[min_index] = lists[min_index].next
return head.next
def main():
sln = Solution()
node1 = ListNode(-129)
node2 = ListNode(-129)
node1.next = node2
print(sln.isPalindrome(node1))
def main():
sln = Solution()
array = [1, 2, 3, 4, 5]
node = ListNode(1)
head = node.toList(array)
print(sln.reverseBetween(head, 2, 4).show())
class Solution:
def reverseList(self, head: ListNode) -> ListNode:
if not head or not head.next:
return head
prev = None
current = head
while current:
next_node = current.next
current.next = prev
prev = current
current = next_node
return prev
l = ListNode(0)
l.next = ListNode(1)
l.next.next = ListNode(2)
solution = Solution()
new_l = solution.reverseList(l)
assert new_l.val == 2
assert new_l.next.val == 1
assert new_l.next.next.val == 0