def add_two_numbers( head1: Optional[SinglyLinkedListNode], head2: Optional[SinglyLinkedListNode] ) -> Optional[SinglyLinkedListNode]: node1 = head1 node2 = head2 dummy_node = SinglyLinkedListNode(0) result = dummy_node carry = 0 while node1 or node2: val1 = 0 val2 = 0 if node1: val1 = node1.data node1 = node1.next if node2: val2 = node2.data node2 = node2.next total = val1 + val2 + carry carry = int(total / 10) result.next = SinglyLinkedListNode(total % 10) result = result.next if carry > 0: result.next = SinglyLinkedListNode(carry) return dummy_node.next
def get_singly_linked_list(values: List[T]) -> SinglyLinkedListNode[T]: dummy = SinglyLinkedListNode() current = dummy for value in values: current.next = SinglyLinkedListNode(value) current = current.next return dummy.next
def test_is_palindrome(): head = SinglyLinkedListNode(1) assert is_palindrome(head) head.next = SinglyLinkedListNode(2) assert not is_palindrome(head) head.next.next = SinglyLinkedListNode(1) assert is_palindrome(head)
def test_append(): test_list = CircularlyLinkedList() test_list.append(SinglyLinkedListNode(1)) assert test_list.all_values() == [1] test_list.append(SinglyLinkedListNode(2)) assert test_list.all_values() == [1, 2] test_list.append(SinglyLinkedListNode(3)) assert test_list.all_values() == [1, 2, 3]
def test_singly_linked_list_node(): node = SinglyLinkedListNode() assert node.next is None assert node.data is None node = SinglyLinkedListNode(1) assert node.data == 1 assert not node.next node = SinglyLinkedListNode(1, SinglyLinkedListNode(2)) assert node.data == 1 assert node.next.data == 2
def test_detect_cycle_with_set(): assert detect_cycle_with_set(SinglyLinkedListNode(1)) is None head = SinglyLinkedListNode(1) head.next = head assert detect_cycle_with_set(head) == head head = SinglyLinkedListNode(1) head.next = SinglyLinkedListNode(2) head.next.next = SinglyLinkedListNode(3) head.next.next.next = SinglyLinkedListNode(4) head.next.next.next.next = head.next assert detect_cycle_with_set(head) == head.next
def test_merge_two_lists(): list1 = SinglyLinkedListNode(1) assert get_list_values(merge_two_lists(list1, None)) == [1] list2 = SinglyLinkedListNode(1) assert get_list_values(merge_two_lists(list1, list2)) == [1, 1] list1.next = SinglyLinkedListNode(2) list1.next.next = SinglyLinkedListNode(4) list2.next = SinglyLinkedListNode(3) list2.next.next = SinglyLinkedListNode(4) assert get_list_values(merge_two_lists(list1, list2)) == [1, 1, 2, 3, 4, 4]
def insert(self, data: T, index: int) -> None: node = SinglyLinkedListNode(data) current_node = self.__head count = 0 while current_node: if count == index: next_node = current_node.next node.next = next_node current_node.next = node return current_node = current_node.next count += 1 if count < index: IndexError('Index out of bounds')
def append(self, node: SinglyLinkedListNode): previous_node = self.head if not previous_node: self.head = node node.next = self.head return while previous_node.next != self.head: previous_node = previous_node.next next_node = previous_node.next previous_node.next = node node.next = next_node
def merge_k_lists( lists: Optional[List[SinglyLinkedListNode]] ) -> Optional[SinglyLinkedListNode]: dummy = SinglyLinkedListNode() current = dummy lists = [val for val in lists if val] while lists: min_node = None smallest = float('inf') for index, head in enumerate(lists): if head and head.data <= smallest: smallest = head.data min_node = index current.next = lists[min_node] if not lists[min_node].next: lists.pop(min_node) else: lists[min_node] = lists[min_node].next current = current.next return dummy.next
def merge_two_lists(head1: Optional[SinglyLinkedListNode], head2: Optional[SinglyLinkedListNode]) -> Optional[SinglyLinkedListNode]: if not head1 and not head2: return None node1 = head1 node2 = head2 dummy_node = SinglyLinkedListNode(0) current_node = dummy_node while node1 and node2: if node1.data <= node2.data: current_node.next = node1 node1 = node1.next else: current_node.next = node2 node2 = node2.next current_node = current_node.next if node1: current_node.next = node1 if node2: current_node.next = node2 return dummy_node.next
def test_remove(): test_list = CircularlyLinkedList() test_list.append(SinglyLinkedListNode(1)) test_list.append(SinglyLinkedListNode(2)) test_list.append(SinglyLinkedListNode(3)) test_list.append(SinglyLinkedListNode(4)) test_list.remove(3) assert test_list.all_values() == [1, 2, 3] test_list.remove(1) assert test_list.all_values() == [1, 3] test_list.remove(0) assert test_list.all_values() == [3] test_list.remove(0) assert test_list.all_values() == []
def reverse_linked_list_recursive( head: SinglyLinkedListNode) -> Optional[SinglyLinkedListNode]: if not head or not head.next: return head new_head = reverse_linked_list_recursive(head.next) head.next.next = head head.next = None return new_head
def append(self, data: T) -> None: node = SinglyLinkedListNode(data) last_node = self.__head while last_node: if not last_node.next: break last_node = last_node.next last_node.next = node
def test_remove_elements(): assert remove_elements(None, 1) is None head = SinglyLinkedListNode(1) assert remove_elements(head, 1) is None assert remove_elements(head, 2) is head head = SinglyLinkedListNode(1) head.next = SinglyLinkedListNode(2) head.next.next = SinglyLinkedListNode(2) head.next.next.next = SinglyLinkedListNode(3) assert get_list_values(remove_elements(head, 2)) == [1, 3]
def test_odd_even_linked_list(): head = SinglyLinkedListNode(1) assert odd_even_list(head) == head head.next = SinglyLinkedListNode(2) head.next.next = SinglyLinkedListNode(3) head.next.next.next = SinglyLinkedListNode(4) head.next.next.next.next = SinglyLinkedListNode(5) assert get_list_values(odd_even_list(head)) == [1, 3, 5, 2, 4]
def test_insert(): head = None assert get_cyclic_list_values(insert(head, 1)) == [1] head = SinglyLinkedListNode(1) head.next = head assert get_cyclic_list_values(insert(head, 2)) == [1, 2] head = SinglyLinkedListNode(3) head.next = SinglyLinkedListNode(4) head.next.next = SinglyLinkedListNode(1) head.next.next.next = head assert get_cyclic_list_values(insert(head, 2)) == [3, 4, 1, 2]
def test_delete_duplicates(): head = None assert delete_duplicates(head) is None head = SinglyLinkedListNode(1) assert get_list_values(delete_duplicates(head)) == [1] head.next = SinglyLinkedListNode(2) head.next.next = SinglyLinkedListNode(2) head.next.next.next = SinglyLinkedListNode(3) head.next.next.next.next = SinglyLinkedListNode(4) head.next.next.next.next.next = SinglyLinkedListNode(4) assert get_list_values(delete_duplicates(head)) == [1, 2, 3, 4]
def remove_elements(head: Optional[SinglyLinkedListNode], data: int) -> Optional[SinglyLinkedListNode]: dummy_node: SinglyLinkedListNode = SinglyLinkedListNode(0) dummy_node.next = head previous: SinglyLinkedListNode = dummy_node current: Optional[SinglyLinkedListNode] = head while current: if current.data == data: previous.next = current.next current = current.next else: previous = current current = current.next return dummy_node.next
def test_find_middle_node(): head = SinglyLinkedListNode(1) assert find_middle_node(head) == head head.next = SinglyLinkedListNode(2) assert find_middle_node(head) == head # 1, 2, 3 head.next.next = SinglyLinkedListNode(3) assert find_middle_node(head) == head.next head.next.next.next = SinglyLinkedListNode(4) assert find_middle_node(head) == head.next
def remove_nth_from_end(head: SinglyLinkedListNode, nth: int) -> Optional[SinglyLinkedListNode]: dummy: SinglyLinkedListNode = SinglyLinkedListNode(0) dummy.next = head previous: SinglyLinkedListNode = dummy lead: SinglyLinkedListNode = dummy # Move lead forward for _ in range(nth + 1): lead = lead.next # Move through list until lead is None while lead: previous = previous.next lead = lead.next # Delete Node by relinking nodes or reassigning head previous.next = previous.next.next return dummy.next
from data_structures.circularly_linked_list import CircularlyLinkedList from data_structures.singly_linked_list_node import SinglyLinkedListNode EMPTY_LIST = CircularlyLinkedList() ONE_NODE_LIST = CircularlyLinkedList(SinglyLinkedListNode(1)) MULTI_NODE_LIST = CircularlyLinkedList(SinglyLinkedListNode(1)) MULTI_NODE_LIST.append(SinglyLinkedListNode(2)) MULTI_NODE_LIST.append(SinglyLinkedListNode(3)) def test_init(): assert EMPTY_LIST.size() == 0 assert EMPTY_LIST.all_values() == [] assert ONE_NODE_LIST.size() == 1 assert ONE_NODE_LIST.all_values() == [1] def test_tail(): assert not EMPTY_LIST.head assert ONE_NODE_LIST.head test_list = CircularlyLinkedList() test_list.head = SinglyLinkedListNode(1) assert test_list.size() == 1 def test_all_values(): assert EMPTY_LIST.all_values() == [] assert ONE_NODE_LIST.all_values() == [1] assert MULTI_NODE_LIST.all_values() == [1, 2, 3]
def __init__(self): self.__head: SinglyLinkedListNode = SinglyLinkedListNode()
def test_rotate_list(): head = None assert rotate_list(head, 1) is None head = SinglyLinkedListNode(1) assert get_list_values(rotate_list(head, 1)) == [1] assert get_list_values(rotate_list(head, 3)) == [1] head.next = SinglyLinkedListNode(2) assert get_list_values(rotate_list(head, 1)) == [2, 1] head = SinglyLinkedListNode(1) head.next = SinglyLinkedListNode(2) head.next.next = SinglyLinkedListNode(3) head.next.next.next = SinglyLinkedListNode(4) head.next.next.next.next = SinglyLinkedListNode(5) assert get_list_values(rotate_list(head, 2)) == [4, 5, 1, 2, 3]
def test_reverse_linked_list(): head = SinglyLinkedListNode(1) head.next = SinglyLinkedListNode(2) head.next.next = SinglyLinkedListNode(3) assert get_list_values(reverse_linked_list_recursive(head)) == [3, 2, 1] head = SinglyLinkedListNode(1) head.next = SinglyLinkedListNode(2) assert get_list_values(reverse_linked_list_recursive(head)) == [2, 1] head = SinglyLinkedListNode(1) assert get_list_values(reverse_linked_list_recursive(head)) == [1]
def test_get_intersection_node(): head1 = SinglyLinkedListNode(1) head1.next = SinglyLinkedListNode(2) head2 = SinglyLinkedListNode(1) head2.next = SinglyLinkedListNode(2) head2.next.next = SinglyLinkedListNode(3) assert get_intersection_node(head1, head2) is None head1 = SinglyLinkedListNode(1) head2 = head1 assert get_intersection_node(head1, head2) is head1 head1 = SinglyLinkedListNode(1) head1.next = SinglyLinkedListNode(2) head1.next.next = SinglyLinkedListNode(3) head1.next.next.next = SinglyLinkedListNode(4) head2 = SinglyLinkedListNode(1) head2.next = head1.next.next assert get_intersection_node(head1, head2) is head1.next.next
def insert(head: Optional[SinglyLinkedListNode], value: int) -> Optional[SinglyLinkedListNode]: if not head: cyclic_list = SinglyLinkedListNode(value) cyclic_list.next = cyclic_list return cyclic_list previous = head node = head.next while node: if previous.data <= value <= node.data: new_node = SinglyLinkedListNode(value) previous.next = new_node new_node.next = node return head if previous.data > node.data: if value >= previous.data or value <= node.data: new_node = SinglyLinkedListNode(value) previous.next = new_node new_node.next = node return head previous = node node = node.next if previous == head: break new_node = SinglyLinkedListNode(value) previous.next = new_node new_node.next = node return head
def test_add_two_numbers(): head1 = SinglyLinkedListNode(1) head1.next = SinglyLinkedListNode(2) head1.next.next = SinglyLinkedListNode(3) head2 = None assert get_list_values(add_two_numbers(head1, head2)) == [1, 2, 3] head1 = SinglyLinkedListNode(5) head2 = SinglyLinkedListNode(5) assert get_list_values(add_two_numbers(head1, head2)) == [0, 1] head1.next = SinglyLinkedListNode(2) head2.next = SinglyLinkedListNode(3) head2.next.next = SinglyLinkedListNode(4) assert get_list_values(add_two_numbers(head1, head2)) == [0, 6, 4]
def test_remove_nth_from_end(): head = SinglyLinkedListNode(1) assert remove_nth_from_end(head, 1) is None head = SinglyLinkedListNode(1) head.next = SinglyLinkedListNode(2) assert remove_nth_from_end(head, 2).data == 2 assert remove_nth_from_end(head, 1).data == 1 head = SinglyLinkedListNode(1) head.next = SinglyLinkedListNode(2) head.next.next = SinglyLinkedListNode(3) head.next.next.next = SinglyLinkedListNode(4) assert remove_nth_from_end(head, 2).next.next.data == 4
def test_tail(): assert not EMPTY_LIST.head assert ONE_NODE_LIST.head test_list = CircularlyLinkedList() test_list.head = SinglyLinkedListNode(1) assert test_list.size() == 1