while node and node.next:
node = node.next
return node
def flatten(self, head: 'Node') -> 'Node':
node = head
while node:
if node.child:
# put child list between current and next node
tail = self.getTail(node.child)
tail.next = node.next
if tail.next:
node.next.prev = tail
node.next = node.child
node.child.prev = node
node.child = None
# go next node (if was node.child, we proceed with them)
node = node.next
return head
if __name__ == '__main__':
ln1 = Node(val=1, prev=None, next=None, child=None)
ln2 = Node(val=2, prev=None, next=None, child=None)
ln3 = Node(val=3, prev=None, next=None, child=None)
ln1.next = ln2
ln2.prev = ln1
ln1.child = ln3
sol = Solution()
assert traverse(sol.flatten(ln1)) == [1, 3, 2]
list_values.sort()
head = None
prev = None
for v in list_values:
node = ListNode(v)
if not head:
head = prev = node
else:
prev.next = node # make link to the new node
prev = node # remember the new node for next iteration
return head
if __name__ == '__main__':
def get_tc():
return [(
make_linked_list_from_iterable([1, 2, 4]),
make_linked_list_from_iterable([1, 3, 4]),
make_linked_list_from_iterable([1, 1, 2, 3, 4, 4]),
)]
solutions = [Solution(), Solution2(), Solution3()]
for s in solutions:
print()
for l1, l2, exp in get_tc():
assert traverse(s.mergeTwoLists(
l1,
l2)) == traverse(exp), f'{s.__class__.__name__} test failed'
head = prev
else:
prev.next = new_node
prev = new_node
sum_head = self.reverse_linked_list(head)
return sum_head
def reverse_linked_list(self, head: ListNode) -> ListNode:
node = head
prev = None
while node:
next_node = node.next
node.next = prev
prev = node
node = next_node
return prev
if __name__ == '__main__':
solutions = [Solution()]
tc = (([7, 2, 4,
3], [5, 6, 4], [7, 8, 0,
7]), ([2, 4, 3], [5, 6, 4], [8, 0,
7]), ([0], [0], [0]))
for sol in solutions:
for a, b, expected_c in tc:
a_list = make_linked_list_from_iterable(a)
b_list = make_linked_list_from_iterable(b)
c_arr = traverse(sol.addTwoNumbers(a_list, b_list))
assert c_arr == expected_c
while size < total_length:
dummy_start = dummy
start = dummy.next
while start:
left = start
right = self.split(left,
size) # start from left, cut with size=size
start = self.split(
right, size) # start from right, cut with size=size
dummy_start = self.merge(
left, right,
dummy_start) # returned tail = next dummy_start
size *= 2
return dummy.next
if __name__ == '__main__':
solutions = [Solution(), Solution2()]
tc = (
([4, 2, 1, 3], [1, 2, 3, 4]),
([-1, 5, 3, 4, 0], [-1, 0, 3, 4, 5]),
([], []),
)
for s in solutions:
for inp, exp in tc:
res = s.sortList(make_linked_list_from_iterable(inp))
assert traverse(
res
) == exp, f"{s.__class__.__name__}: expected {exp}, got {traverse(res)}"
if curr.next == head:
break
curr = curr.next
new_node = Node(insertVal)
next_node = curr.next
curr.next = new_node
new_node.next = next_node
return head
if __name__ == '__main__':
def get_tc():
return [
([3, 4, 1], 2, [3, 4, 1, 2]),
([], 1, [1]),
([1], 0, [1, 0]),
([1, 3, 5], 2, [1, 2, 3, 5]),
([3, 3, 3], 0, [3, 3, 3, 0]),
([1, 3, 5], 1, [1, 1, 3, 5]),
]
solutions = [Solution(), Solution2()]
for s in solutions:
for inp_list, insert_val, output_list in get_tc():
input_ll = make_circulated_linked_list(inp_list)
result = s.insert(input_ll, insert_val)
assert traverse(result) == output_list
return
odd = head
even = head.next
even_head = even
while even and even.next:
odd.next = even.next # make link from one odd to another odd
odd = odd.next # switch odd to next odd one (for next iteration)
even.next = odd.next # make link from even to next even too
even = even.next # switch even to next even one (for next iteration)
# now odd is the tail of list of odd-idx items. Simply extend it with the even-idx list using its head.
odd.next = even_head
return head
if __name__ == '__main__':
def get_tc():
return [([1, 2, 3, 4, 5], [1, 3, 5, 2, 4]),
([2, 1, 3, 5, 6, 4, 7], [2, 3, 6, 7, 1, 5, 4])]
solutions = [Solution(), Solution2()]
for s in solutions:
for inp, exp in get_tc():
res = s.oddEvenList(make_linked_list_from_iterable(inp))
assert traverse(
res
) == exp, f'\nInput:\t\t{inp}\nResult:\t\t{traverse(res)}\nExpected:\t{exp}'
node = head
while node and node.next:
len_values += 1
node = node.next
old_tail = node
old_tail.next = head # close the ring
shift = len_values - (k % len_values) - 1
node = head
idx = 0
while idx != shift:
node = node.next
idx += 1
new_tail = node
new_head = node.next
new_tail.next = None # break the ring
return new_head
if __name__ == '__main__':
solutions = [Solution(), Solution2()]
tc = [
([1, 2, 3, 4, 5], 2, [4, 5, 1, 2, 3]),
([0, 1, 2], 4, [2, 0, 1]),
]
for sol in solutions:
for inp, rotate_count, exp in tc:
inp_head = make_linked_list_from_iterable(inp)
res = sol.rotateRight(inp_head, rotate_count)
assert traverse(res) == exp, f'Want {exp}, got {traverse(res)}'