def example():
ll = LinkedList.generate(100, 0, 9)
print(ll)
remove_dups(ll)
print(ll)
ll = LinkedList.generate(100, 0, 9)
print(ll)
remove_dups_followup(ll)
print(ll)
def test_loop_detection():
looped_list = LinkedList(["A", "B", "C", "D", "E"])
loop_start_node = looped_list.head.next.next
looped_list.tail.next = loop_start_node
tests = [
(LinkedList(), None),
((LinkedList((1, 2, 3))), None),
(looped_list, loop_start_node),
]
for ll, expected in tests:
assert loop_detection(ll) == expected
def test_linked_list_intersection():
shared = LinkedList()
shared.add_multiple([1, 2, 3, 4])
a = LinkedList([10, 11, 12, 13, 14, 15])
b = LinkedList([20, 21, 22])
a.tail.next = shared.head
a.tail = shared.tail
b.tail.next = shared.head
b.tail = shared.tail
# should be 1
assert intersection(a, b).value == 1
def test_create_node_list_by_depth():
for f in testable_functions:
node_h = BinaryNode("H")
node_g = BinaryNode("G")
node_f = BinaryNode("F")
node_e = BinaryNode("E", node_g)
node_d = BinaryNode("D", node_h)
node_c = BinaryNode("C", None, node_f)
node_b = BinaryNode("B", node_d, node_e)
node_a = BinaryNode("A", node_b, node_c)
lists = f(node_a)
assert lists[0].values() == LinkedList([node_a]).values()
assert lists[1].values() == LinkedList([node_b, node_c]).values()
assert lists[2].values() == LinkedList([node_d, node_e,
node_f]).values()
assert lists[3].values() == LinkedList([node_h, node_g]).values()
def create_node_list_by_depth_b(tree):
if not tree:
return []
curr = tree
result = [LinkedList([curr])]
level = 0
while result[level]:
result.append(LinkedList())
for linked_list_node in result[level]:
n = linked_list_node.value
if n.left:
result[level + 1].add(n.left)
if n.right:
result[level + 1].add(n.right)
level += 1
return result
def test_is_palindrome():
for f in testable_functions:
start = time.perf_counter()
for values, expected in test_cases:
print(f"{f.__name__}: {values}")
for _ in range(100):
assert f(LinkedList(values)) == expected
duration = time.perf_counter() - start
print(f"{f.__name__} {duration * 1000:.1f}ms")
def sum_lists_followup(ll_a, ll_b):
# Pad the shorter list with zeros
if len(ll_a) < len(ll_b):
for i in range(len(ll_b) - len(ll_a)):
ll_a.add_to_beginning(0)
else:
for i in range(len(ll_a) - len(ll_b)):
ll_b.add_to_beginning(0)
# Find sum
n1, n2 = ll_a.head, ll_b.head
result = 0
while n1 and n2:
result = (result * 10) + n1.value + n2.value
n1 = n1.next
n2 = n2.next
# Create new linked list
ll = LinkedList()
ll.add_multiple([int(i) for i in str(result)])
return ll
def test_remove_dupes():
for f in testable_functions:
start = time.perf_counter()
for _ in range(100):
for values, expected in test_cases:
expected = expected.copy()
deduped = f(LinkedList(values))
assert deduped.values() == expected
deduped.add(5)
expected.append(5)
assert deduped.values() == expected
duration = time.perf_counter() - start
print(f"{f.__name__} {duration * 1000:.1f}ms")
def create_node_list_by_depth(tree_root):
# BFS.
levels = {}
q = deque()
q.append((tree_root, 0))
while len(q) > 0:
node, level = q.popleft()
if level not in levels:
# First node in the level
levels[level] = LinkedList()
# Nodes already exist
levels[level].add(node)
# Push onto queue
if node.left:
q.append((node.left, level + 1))
if node.right:
q.append((node.right, level + 1))
return levels
def sum_lists(ll_a, ll_b):
n1, n2 = ll_a.head, ll_b.head
ll = LinkedList()
carry = 0
while n1 or n2:
result = carry
if n1:
result += n1.value
n1 = n1.next
if n2:
result += n2.value
n2 = n2.next
ll.add(result % 10)
carry = result // 10
if carry:
ll.add(carry)
return ll
def test_kth_to_last():
for linked_list_values, k, expected in test_cases:
ll = LinkedList(linked_list_values)
assert kth_to_last(ll, k).value == expected
def test_is_palindrome():
ll_true = LinkedList([1, 2, 3, 4, 5, 4, 3, 2, 1])
assert is_palindrome(ll_true)
ll_false = LinkedList([1, 2, 3, 4, 5, 6, 7, 8, 9])
assert not is_palindrome(ll_false)
def example():
ll_a = LinkedList.generate(4, 0, 9)
ll_b = LinkedList.generate(3, 0, 9)
print(ll_a)
print(ll_b)
print(sum_lists(ll_a, ll_b))
# Pad the shorter list with zeros
if len(ll_a) < len(ll_b):
for i in range(len(ll_b) - len(ll_a)):
ll_a.add_to_beginning(0)
else:
for i in range(len(ll_a) - len(ll_b)):
ll_b.add_to_beginning(0)
# Find sum
n1, n2 = ll_a.head, ll_b.head
result = 0
while n1 and n2:
result = (result * 10) + n1.value + n2.value
n1 = n1.next
n2 = n2.next
# Create new linked list
ll = LinkedList()
ll.add_multiple([int(i) for i in str(result)])
return ll
if __name__ == "__main__":
ll_a = LinkedList.generate(4, 0, 9)
ll_b = LinkedList.generate(3, 0, 9)
print(ll_a)
print(ll_b)
print(sum_lists(ll_a, ll_b))
print(sum_lists_followup(ll_a, ll_b))
)
def test_remove_dupes():
for f in testable_functions:
start = time.perf_counter()
for _ in range(100):
for values, expected in test_cases:
expected = expected.copy()
deduped = f(LinkedList(values))
assert deduped.values() == expected
deduped.add(5)
expected.append(5)
assert deduped.values() == expected
duration = time.perf_counter() - start
print(f"{f.__name__} {duration * 1000:.1f}ms")
if __name__ == "__main__":
ll = LinkedList.generate(100, 0, 9)
print(ll)
remove_dups(ll)
print(ll)
ll = LinkedList.generate(100, 0, 9)
print(ll)
remove_dups_followup(ll)
print(ll)
from chapter_02.linked_list import LinkedList
def delete_middle_node(node):
node.value = node.next.value
node.next = node.next.next
if __name__ == "__main__":
ll = LinkedList()
ll.add_multiple([1, 2, 3, 4])
middle_node = ll.add(5)
ll.add_multiple([7, 8, 9])
print(ll)
delete_middle_node(middle_node)
print(ll)
from chapter_02.linked_list import LinkedList
def partition(ll, x):
current = ll.tail = ll.head
while current:
nextNode = current.next
current.next = None
if current.value < x:
current.next = ll.head
ll.head = current
else:
ll.tail.next = current
ll.tail = current
current = nextNode
# Error check in case all nodes are less than x
if ll.tail.next is not None:
ll.tail.next = None
if __name__ == "__main__":
ll = LinkedList.generate(10, 0, 99)
print(ll)
partition(ll, ll.head.value)
print(ll)
def example():
ll = LinkedList([3, 5, 8, 5, 10, 2, 1])
print(ll)
partition(ll, 5)
print(ll)
def example():
ll = LinkedList.generate(10, 0, 99)
print(ll)
partition(ll, ll.head.value)
print(ll)
