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
