def test_solution(self): self.assertEqual( False, Solution().isPalindrome(common.create_linked_list([1, 2]))) self.assertEqual( True, Solution().isPalindrome(common.create_linked_list([1, 2, 2, 1])))
def test_solution(self): self.assertEqual( [1, 3, 5, 2, 4], common.convert_linked_list_to_list( Solution().oddEvenList(common.create_linked_list([1, 2, 3, 4, 5])))) self.assertEqual( [2, 3, 6, 7, 1, 5, 4], common.convert_linked_list_to_list( Solution().oddEvenList(common.create_linked_list([2, 1, 3, 5, 6, 4, 7]))))
def test_solution(self): self.assertEqual([1, 2, 3, 4], common.convert_linked_list_to_list( Solution().insertionSortList( common.create_linked_list([4, 2, 1, 3])))) self.assertEqual([-1, 0, 3, 4, 5], common.convert_linked_list_to_list( Solution().insertionSortList( common.create_linked_list([-1, 5, 3, 4, 0]))))
def test_solution(self): self.assertEqual([1, 2], common.convert_linked_list_to_list( Solution().deleteDuplicates( common.create_linked_list([1, 1, 2])))) self.assertEqual([1, 2, 3], common.convert_linked_list_to_list( Solution().deleteDuplicates( common.create_linked_list([1, 1, 2, 3, 3]))))
def test_solution(self): l = common.create_linked_list([1, 2, 3, 4]) end_node = common.get_linked_list_node(l, 3) end_node.next = common.get_linked_list_node(l, 1) self.assertEqual(True, Solution().hasCycle(l)) l = common.create_linked_list([1, 2]) end_node = common.get_linked_list_node(l, 1) end_node.next = common.get_linked_list_node(l, 0) self.assertEqual(True, Solution().hasCycle(l)) self.assertEqual(False, Solution().hasCycle(common.create_linked_list([1])))
def test_solution(self): l = common.create_linked_list([1, 2, 3, 4]) Solution().reorderList(l) self.assertEqual([1, 4, 2, 3], common.convert_linked_list_to_list(l)) l = common.create_linked_list([1, 2, 3, 4, 5]) Solution().reorderList(l) self.assertEqual([1, 5, 2, 4, 3], common.convert_linked_list_to_list(l)) l = common.create_linked_list([]) Solution().reorderList(l) self.assertEqual([], common.convert_linked_list_to_list(l))
def test_solution(self): self.assertEqual( [2, 1, 4, 3, 5], common.convert_linked_list_to_list(Solution().reverseKGroup( common.create_linked_list([1, 2, 3, 4, 5]), 2))) self.assertEqual( [3, 2, 1, 4, 5], common.convert_linked_list_to_list(Solution().reverseKGroup( common.create_linked_list([1, 2, 3, 4, 5]), 3))) self.assertEqual([2, 1], common.convert_linked_list_to_list( Solution().reverseKGroup( common.create_linked_list([1, 2]), 2)))
def test_solution(self): self.assertEqual( [4, 5, 1, 2, 3], common.convert_linked_list_to_list(Solution().rotateRight( common.create_linked_list([1, 2, 3, 4, 5]), 2))) self.assertEqual([2, 0, 1], common.convert_linked_list_to_list( Solution().rotateRight( common.create_linked_list([0, 1, 2]), 4))) self.assertEqual([1], common.convert_linked_list_to_list( Solution().rotateRight( common.create_linked_list([1]), 1)))
def test_solution(self): l = common.create_linked_list([4, 5, 1, 9]) Solution().deleteNode(common.get_linked_list_node(l, 1)) self.assertEqual( [4, 1, 9], common.convert_linked_list_to_list(l) ) l = common.create_linked_list([4, 5, 1, 9]) Solution().deleteNode(common.get_linked_list_node(l, 2)) self.assertEqual( [4, 5, 9], common.convert_linked_list_to_list(l) )
def test_solution(self): lists = [ common.create_linked_list([1, 4, 5]), common.create_linked_list([1, 3, 4]), common.create_linked_list([2, 6]), ] self.assertEqual([1, 1, 2, 3, 4, 4, 5, 6], common.convert_linked_list_to_list( Solution().mergeKLists(lists))) lists = [ common.create_linked_list([]), common.create_linked_list([1]), ] self.assertEqual([1], common.convert_linked_list_to_list( Solution().mergeKLists(lists)))
def test_solution(self): l = common.create_linked_list([1, 2, 3, 4]) end_node = common.get_linked_list_node(l, 3) end_node.next = common.get_linked_list_node(l, 1) self.assertEqual(common.get_linked_list_node(l, 1), Solution().detectCycle(l)) l = common.create_linked_list([1, 2]) end_node = common.get_linked_list_node(l, 1) end_node.next = common.get_linked_list_node(l, 0) self.assertEqual(common.get_linked_list_node(l, 0), Solution().detectCycle(l)) self.assertEqual( None, Solution().detectCycle(common.create_linked_list([1])))
def test_solution(self): self.assertEqual( [1, 2, 3, 4, 5], common.convert_linked_list_to_list( Solution().removeElements(common.create_linked_list([1, 2, 6, 3, 4, 5, 6]), 6)))
if fast_runner == slow_runner: break if fast_runner is None or fast_runner.next is None: return None slow_runner = first_node while fast_runner is not slow_runner: fast_runner = fast_runner.next slow_runner = slow_runner.next return fast_runner def print_result(loop_node: LinkedListNode): is_looped = loop_node is not None print(f'IS looped (id {loop_node.id})' if is_looped else 'Is NOT looped') if __name__ == '__main__': looped_list = create_linked_list(20) get_linked_list_last_node( looped_list).next = looped_list.next.next.next.next.next.next.next non_looped_list = create_linked_list(20) print() print_result(check_is_looped_list1(looped_list)) print_result(check_is_looped_list1(non_looped_list)) print() print_result(check_is_looped_list2(looped_list)) print_result(check_is_looped_list2(non_looped_list)) print()
def test_solution(self): self.assertEqual([1, 1, 2, 3, 4, 4], common.convert_linked_list_to_list( Solution().mergeTwoLists( common.create_linked_list([1, 2, 4]), common.create_linked_list([1, 3, 4]))))
def test_solution(self): self.assertEqual( [1, 2, 2, 4, 3, 5], common.convert_linked_list_to_list(Solution().partition( common.create_linked_list([1, 4, 3, 2, 5, 2]), 3)))
while first.next is not None: first_length += 1 first = first.next second_length = 1 while second.next is not None: second_length += 1 second = second.next return first == second, first_length, second_length def get_intersecting_message(node: LinkedListNode) -> str: return 'not intersecting' if node is None else f'intersecting (id {str(node.id)})' if __name__ == '__main__': first_non_intersecting = create_linked_list(10) second_non_intersecting = create_linked_list(13) first_intersecting = create_linked_list(20) second_intersecting = create_linked_list(10) intersecting_node = first_intersecting.next.next.next.next.next.next.next.next.next.next.next.next.next intersecting_node.next = second_intersecting.next.next.next candidate = check_node_intersection1(first_non_intersecting, second_non_intersecting) print('Expect non-intersection, and is: ' + get_intersecting_message(candidate)) print() candidate = check_node_intersection1(first_intersecting, second_intersecting) print('Expect intersection, and is: ' +
from models.linked_list_node import LinkedListNode def partition_linked_list(current_node: LinkedListNode, partition: int): if current_node.next is not None: (connect_node, last_node) = partition_linked_list(current_node.next, partition) else: return (current_node, current_node) if current_node.value >= partition and current_node.next is not None: last_node.next = current_node current_node.next = None return (connect_node, current_node) else: current_node.next = connect_node return (current_node, last_node) if __name__ == '__main__': node_count = 20 first_node = create_linked_list(node_count) print_linked_list('Initial list 1:', first_node) print() partition = int(input('Partition value: ')) (first_node, _) = partition_linked_list(first_node, partition) print_linked_list('After partitioning:', first_node) print()
def test_solution(self): self.assertEqual( [1, 4, 3, 2, 5], common.convert_linked_list_to_list( Solution().reverseBetween(common.create_linked_list([1, 2, 3, 4, 5]), 2, 4)))
def test_solution(self): self.assertEqual( [5, 4, 3, 2, 1], common.convert_linked_list_to_list( Solution().reverseList(common.create_linked_list([1, 2, 3, 4, 5]))) )
def test_solution(self): n1 = common.create_linked_list([2, 4, 3]) n2 = common.create_linked_list([5, 6, 4]) n3 = Solution().addTwoNumbers(n1, n2) self.assertEqual([7, 0, 8], common.convert_linked_list_to_list(n3))
def test_solution(self): self.assertEqual( [1, 2, 3, 5], common.convert_linked_list_to_list(Solution().removeNthFromEnd( common.create_linked_list([1, 2, 3, 4, 5]), 2)))
def test_solution(self): self.assertEqual( [0, -3, 9, -10, None, 5], common.convert_binary_tree_to_list(Solution().sortedListToBST( common.create_linked_list([-10, -3, 0, 5, 9]))))
result = node return (result, carryover) def pad_linked_list_from_left(head: LinkedListNode, count: int, value: int): node = None for i in range(count): node = LinkedListNode(head.id - 1, value) node.next = head head = node return node if __name__ == '__main__': first_number = create_linked_list(3) print_linked_list('First number reverse:', first_number) second_number = create_linked_list(3) print_linked_list('Second number reverse:', second_number) print() sum = linked_list_to_number_reverse_order(first_number) + linked_list_to_number_reverse_order(second_number) print(f'Sum (reverse): {sum}') print_linked_list('Sum list (reverse):', number_to_linked_list_reverse_order(sum)) print() first_number = create_linked_list(3) print_linked_list('First number forward:', first_number) second_number = create_linked_list(3) print_linked_list('Second number forward:', second_number)