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)}'