class deleteFromMiddleTests(unittest.TestCase):
def setUp(self):
self.linked_list = SinglyLinkedList(SinglyLinkedNode(0))
for i in range(3):
self.linked_list.append(SinglyLinkedNode(i+1))
def test_1(self):
node = self.linked_list.head.child
deleteFromMiddle(node)
traversal = self.linked_list.traverse()
self.assertEqual(len(traversal), 3)
self.assertEqual(traversal, [0, 2, 3])
def test_2(self):
node = self.linked_list.head.child.child
deleteFromMiddle(node)
traversal = self.linked_list.traverse()
self.assertEqual(len(traversal), 3)
self.assertEqual(traversal, [0, 1, 3])
def test_3(self):
for _ in range(2):
node = self.linked_list.head.child
deleteFromMiddle(node)
traversal = self.linked_list.traverse()
self.assertEqual(len(traversal), 2)
self.assertEqual(traversal, [0, 3])
def test_4(self):
node = self.linked_list.head.child.child.child
self.assertRaises(ValueError, deleteFromMiddle, node)
def merge(a, b):
'''
Merges two linked list sorting data in the nodes
Returns a list_merged linked list
'''
list_merged = SinglyLinkedList()
list_merged.prepend(Node(
0)) # Add a fake head that is discarted later to avoid empty lists
current = list_merged.head
a_head = a.head
b_head = b.head
# Iterate over each node until we reach the tail one and build the list by updating the current next node
while a_head != None or b_head != None:
if a_head is None:
current.next = b_head
b_head = b_head.next
elif b_head is None:
current.next = a_head
a_head = a_head.next
else:
if a_head.data < b_head.data:
current.next = a_head
a_head = a_head.next
else:
current.next = b_head
b_head = b_head.next
current = current.next
# Discard fake head and set first list_merged node as head
list_merged.head = list_merged.head.next
return list_merged
class deleteFromMiddleTests(unittest.TestCase):
def setUp(self):
self.linked_list = SinglyLinkedList(SinglyLinkedNode(0))
for i in range(3):
self.linked_list.append(SinglyLinkedNode(i + 1))
def test_1(self):
node = self.linked_list.head.child
deleteFromMiddle(node)
traversal = self.linked_list.traverse()
self.assertEqual(len(traversal), 3)
self.assertEqual(traversal, [0, 2, 3])
def test_2(self):
node = self.linked_list.head.child.child
deleteFromMiddle(node)
traversal = self.linked_list.traverse()
self.assertEqual(len(traversal), 3)
self.assertEqual(traversal, [0, 1, 3])
def test_3(self):
for _ in range(2):
node = self.linked_list.head.child
deleteFromMiddle(node)
traversal = self.linked_list.traverse()
self.assertEqual(len(traversal), 2)
self.assertEqual(traversal, [0, 3])
def test_4(self):
node = self.linked_list.head.child.child.child
self.assertRaises(ValueError, deleteFromMiddle, node)
class Stack:
def __init__(self):
self.s = SinglyLinkedList()
def push(self, value):
self.s.insert_start(value)
def pop(self):
return self.s.delete_start()
def print_stack(self):
self.s.print_linklist()
def is_empty(self):
if self.s.size == 0:
return True
return False
def __len__(self):
return self.s.size
def peek(self):
if self.is_empty():
print("Stack is empty")
return
return self.s.head.data
class Queue:
def __init__(self):
self.s = SinglyLinkedList()
def enqueue(self, value):
self.s.insert_last(value)
def dequeue(self):
return self.s.delete_start()
def print_queue(self):
self.s.print_linklist()
def is_empty(self):
if self.s.size == 0:
return True
return False
def __len__(self):
return self.s.size
def peek(self):
if self.is_empty():
print("Queue is empty")
return
return self.s.head.data
def setup_method(self):
self.test_list = SinglyLinkedList()
self.test_list.append(42)
self.test_list.append(33)
self.test_list.append('spam')
self.test_list.prepend([])
self.test_list.prepend({'a': 42})
def test_inequality_with_different_nodes(self):
first = SinglyLinkedList()
first.append(100)
second = SinglyLinkedList()
second.append(100)
second.append(200)
second.append(300)
self.assertNotEqual(first, second)
def test_2(self):
linked_list = SinglyLinkedList()
values = [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
for value in values:
linked_list.append(SinglyLinkedNode(value))
partition(linked_list, 10)
traversal = linked_list.traverse()
self.assertEqual(traversal, [9, 8, 7, 6, 5, 4, 3, 2, 1, 10])
def test_linked_list_empty():
"""test_linked_list_empty."""
ll = SinglyLinkedList()
for _ in ll:
raise AssertionError("Collection should be empty, iterator returned.")
assert not any(value in ll for value in range(-100, 100))
assert ll.remove(5) is None
assert len(ll) is 0
print("No items, ", ll)
print("Passed all tests for empty linked list.")
def test_2(self):
linked_list = SinglyLinkedList()
values = [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
for value in values:
linked_list.append(SinglyLinkedNode(value))
partition(linked_list, 10)
traversal = linked_list.traverse()
self.assertEqual(traversal, [9, 8, 7, 6, 5, 4, 3, 2, 1, 10])
def test_remove_at_the_beginning_with_multiple_values(self):
linked = SinglyLinkedList(100)
linked.append(200)
linked.append(300)
linked.append(400)
linked.remove(0)
self.assertEqual(linked.as_list(), [200, 300, 400])
def test_1(self):
linked_list = SinglyLinkedList()
values = [3, 5, 8, 5, 10, 2, 1]
for value in values:
linked_list.append(SinglyLinkedNode(value))
partition(linked_list, 5)
traversal = linked_list.traverse()
self.assertEqual(set(traversal[:3]), set([1, 2, 3]))
self.assertEqual(set(traversal[3:]), set([5, 8, 10]))
self.assertEqual(len(traversal), 7)
def test_1(self):
linked_list = SinglyLinkedList()
values = [3, 5, 8, 5, 10, 2, 1]
for value in values:
linked_list.append(SinglyLinkedNode(value))
partition(linked_list, 5)
traversal = linked_list.traverse()
self.assertEqual(set(traversal[:3]), set([1,2,3]))
self.assertEqual(set(traversal[3:]), set([5, 8, 10]))
self.assertEqual(len(traversal), 7)
def test_remove_at_the_end(self):
linked = SinglyLinkedList(100)
linked.append(200)
linked.append(300)
linked.append(400)
linked.append(500)
linked.remove(4)
self.assertEqual(linked.as_list(), [100, 200, 300, 400])
def test_3(self):
linked_list = SinglyLinkedList(SinglyLinkedNode(0))
last = 100000
current = last
current_node = SinglyLinkedNode(current)
while current > 0:
current -= 1
current_node = SinglyLinkedNode(current, current_node)
linked_list.append(current_node)
k = 7623
self.assertEqual(toLast(k, linked_list), last - k)
def sumLists(a, b):
current_a = a.head
current_b = b.head
result = SinglyLinkedList()
# Digit addition step
while (current_a is not None) and (current_b is not None):
result.append(SinglyLinkedNode(current_a.value + current_b.value))
current_a = current_a.child
current_b = current_b.child
while current_a is not None:
result.append(SinglyLinkedNode(current_a.value))
current_a = current_a.child
while current_b is not None:
result.append(SinglyLinkedNode(current_b.value))
current_b = current_b.child
# Carries step
current_result = result.head
while current_result is not None:
if current_result.value >= 10:
carry = int(current_result.value / 10)
current_result.value = current_result.value - 10 * carry
if current_result.child is not None:
current_result.child.value += carry
else:
current_result.child = SinglyLinkedNode(carry)
current_result = current_result.child
return result
def palindromic(l):
r = SinglyLinkedList()
current = l.head
while current is not None:
r.prepend(SinglyLinkedNode(current.value))
current = current.child
l_iter = l.head
r_iter = r.head
while l_iter is not None:
if l_iter.value != r_iter.value:
return False
l_iter = l_iter.child
r_iter = r_iter.child
return True
def palindromic(l):
r = SinglyLinkedList()
current = l.head
while current is not None:
r.prepend(SinglyLinkedNode(current.value))
current = current.child
l_iter = l.head
r_iter = r.head
while l_iter is not None:
if l_iter.value != r_iter.value:
return False
l_iter = l_iter.child
r_iter = r_iter.child
return True
def linked_list_sum(first, second):
head = None
current = None
carry = 0
while first != None or second != None or carry != 0:
if first != None:
first_num = first.value
first = first.next
else:
first_num = 0
if second != None:
second_num = second.value
second = second.next
else:
second_num = 0
total = first_num + second_num + carry
digit = total % 10
carry = total / 10
new_node = SinglyLinkedList(digit)
if current != None:
current.next = new_node
if head == None:
head = new_node
current = new_node
return head
def split(list):
'''
Splits a linked list into two new ones right in the middle or None in the right if it has 1 node only
'''
left = SinglyLinkedList()
right = SinglyLinkedList()
if list is None or list.head is None:
left = list
right = None
else:
mid_point = list.size() // 2
mid_node = list.node_at_index(mid_point - 1)
left = list
right.head = mid_node.next
mid_node.next = None
return left, right
def create_list(self, length_neck, length_loop):
neck = SinglyLinkedList()
for i in range(length_neck):
neck.prepend(SinglyLinkedNode(length_neck - i))
loop = SinglyLinkedList()
for i in range(length_loop):
loop.prepend(SinglyLinkedNode(length_neck + length_loop - i))
if loop.head is not None:
end = loop.head
while end.child is not None:
end = end.child
end.child = loop.head
neck.append(loop.head)
return neck
def test_linked_list_single_item():
"""test_linked_list_single_item."""
ll = SinglyLinkedList()
ll.prepend(5)
assert ll.head.item is 5
print("One item, ", ll)
for node in ll:
assert node.item is 5
assert 5 in ll
assert not any(value in ll for value in range(-100, 100) if value is not 5)
assert len(ll) is 1
assert ll.remove(5) is 5
assert 5 not in ll
assert len(ll) is 0
for _ in ll:
raise AssertionError("Collection should be empty, iterator returned.")
print("Passed all tests for single item in linked list")
def test_insert_in_the_middle(self):
linked = SinglyLinkedList(100)
linked.append(200)
linked.append(300)
linked.insert(1000, 1)
self.assertEqual(linked.as_list(), [100, 1000, 200, 300])
def sumLists(a, b):
current_a = a.head
current_b = b.head
result = SinglyLinkedList()
# Digit addition step
while (current_a is not None) and (current_b is not None):
result.append(SinglyLinkedNode(current_a.value + current_b.value))
current_a = current_a.child
current_b = current_b.child
while current_a is not None:
result.append(SinglyLinkedNode(current_a.value))
current_a = current_a.child
while current_b is not None:
result.append(SinglyLinkedNode(current_b.value))
current_b = current_b.child
# Carries step
current_result = result.head
while current_result is not None:
if current_result.value >= 10:
carry = int(current_result.value/10)
current_result.value = current_result.value - 10*carry
if current_result.child is not None:
current_result.child.value += carry
else:
current_result.child = SinglyLinkedNode(carry)
current_result = current_result.child
return result
def test_as_list(self):
linked = SinglyLinkedList()
linked.append(100)
linked.append(200)
linked.append(300)
self.assertEqual(linked.as_list(), [100, 200, 300])
def test_remove(self):
linked = SinglyLinkedList(100)
linked.append(200)
linked.append(300)
linked.remove(1)
self.assertEqual(linked.as_list(), [100, 300])
def test_append_multiple_with_initial_value(self):
linked = SinglyLinkedList(1000)
linked.append(100)
linked.append(200)
linked.append(300)
self.assertEqual(linked.as_list(), [1000, 100, 200, 300])
def __init__(self, bin_count=10, max_load=0.7, hashfunc=hash):
"""__init__."""
super(ChainedHashDict, self).__init__()
if bin_count <= 0:
raise TypeError("Bin count must be greater than zero.")
self.table = [SinglyLinkedList() for _ in range(bin_count)]
self.max_load = max_load
self.hash = hashfunc
self.size = 0
def rebuild(self, bincount):
"""rebuild."""
tmp = self.table
self.table = [SinglyLinkedList() for _ in range(bincount)]
self.size = 0
for linked_list in tmp:
for node in linked_list:
self[node.key] = node.item
del tmp
def test_item_setting_by_index_overrides_previous_value_at_the_end(self):
linked = SinglyLinkedList()
linked.append(100)
linked.append(200)
linked.append(300)
linked[2] = 400
self.assertEqual(linked.as_list(), [100, 200, 400])
def time_pop():
n = 50000
print('time_pop, n =', n)
container = SLL(range(n))
with timewith(' linked list '):
for _ in range(n):
container.pop()
del container
container = list(range(n))
with timewith(' list '):
for _ in range(n):
container[0]
del container[0]
del container
container = deque(range(n))
with timewith(' deque '):
for _ in range(n):
container.pop()
del container
def reverse(l: ll):
curr = l.head
prev = None
while curr.next:
next_element = curr.next
curr.next = prev
prev = curr
curr = next_element
l.head = curr
l.head.next = prev
return l
def test_problem(self):
linked_list = SinglyLinkedList(SinglyLinkedNode(-1))
for i in range(100):
linked_list.append(SinglyLinkedNode(i))
linked_list.append(SinglyLinkedNode(i))
for i in range(100):
linked_list.append(SinglyLinkedNode(0))
deduplicate(linked_list)
self.assertEqual(linked_list.traverse(), [-1] + range(100))
def test_direct_access_to_elements_more_than_one_element(self):
linked = SinglyLinkedList()
linked.append(100)
linked.append(200)
linked.append(300)
linked.append(400)
self.assertEqual(linked[2], 300)
class SinglyLinkedListQueue:
def __init__(self, max_length):
self._queue = SinglyLinkedList()
self._length = 0
self._max_length = max_length
def enqueue(self, value):
if self._length == self._max_length:
raise ValueError("Overflow")
self._length += 1
self._queue.append(value)
def dequeue(self):
if self._length == 0:
raise ValueError("Underflow")
self._length -= 1
return self._queue.remove(0).value
def increase_max_length(self):
self._max_length += 1
def as_list(self):
return self._queue.as_list()
def create_list(self, length_neck, length_loop):
neck = SinglyLinkedList()
for i in range(length_neck):
neck.prepend(SinglyLinkedNode(length_neck - i))
loop = SinglyLinkedList()
for i in range(length_loop):
loop.prepend(SinglyLinkedNode(length_neck + length_loop - i))
if loop.head is not None:
end = loop.head
while end.child is not None:
end = end.child
end.child = loop.head
neck.append(loop.head)
return neck
def list_rep(self, a_string):
a = SinglyLinkedList()
for digit in a_string:
a.prepend(SinglyLinkedNode(int(digit)))
return a
def test_2(self):
linked_list = SinglyLinkedList(SinglyLinkedNode(-1))
for i in range(100):
linked_list.append(SinglyLinkedNode(i))
self.assertIsNone(toLast(1000, linked_list))
def test_1(self):
linked_list = SinglyLinkedList(SinglyLinkedNode(0))
for i in range(1, 100):
linked_list.append(SinglyLinkedNode(i))
self.assertEqual(toLast(1, linked_list), 98)
def build_list(self, values):
l = SinglyLinkedList()
for value in values[::-1]:
l.prepend(SinglyLinkedNode(value))
return l
def setUp(self):
self.linked_list = SinglyLinkedList(SinglyLinkedNode(0))
for i in range(3):
self.linked_list.append(SinglyLinkedNode(i+1))
def build_list_from_string(self, s):
l = SinglyLinkedList()
for c in s[::-1]:
l.prepend(SinglyLinkedNode(c))
return l
