def add_entry(self, key, value):
hash_for_item_to_add = self._compute_hash_code(key)
index_for_item_to_add = self._compute_index_from_hash(
hash_for_item_to_add)
hash_table_entry = HashTableEntry(key, value)
node_to_add = LinkedListNode(hash_table_entry)
if self.data_array[index_for_item_to_add] == None:
linked_list = LinkedList()
linked_list.add_first(node_to_add)
self.data_array[index_for_item_to_add] = linked_list
self.current_items_count += 1
else: #check if same key exist and update it
linked_list = self.data_array[index_for_item_to_add]
node = linked_list.head
while node != None:
if (node.node_value.key == key):
node.node_value.value = value
break
node = node.next
if node == None: #if key not exist then it is a new element just add it to linked list at that index
linked_list.add_last(node_to_add)
self.current_items_count += 1
self._assure_max_size_Not_exceeded()
def test_delete_nodes(self):
node1 = LinkedListNode("node 1")
node2 = LinkedListNode("node 2")
node3 = LinkedListNode("node 3")
node4 = LinkedListNode("node 4")
my_linked_list = LinkedList()
my_linked_list.add_first(node1)
my_linked_list.add_last(node2)
my_linked_list.add_last(node3)
my_linked_list.add_last(node4)
my_linked_list.delete_node(node1)
self.assertEqual(my_linked_list.length, 3)
self.assertEqual(my_linked_list.head, node2)
my_linked_list.delete_node(node3)
self.assertEqual(my_linked_list.length, 2)
self.assertEqual(my_linked_list.get_node_by_index(1), node4)
my_linked_list.delete_node(node4)
self.assertEqual(my_linked_list.length, 1)
self.assertEqual(my_linked_list.head, node2)
self.assertEqual(my_linked_list.tail, node2)
with self.assertRaises(ValueError):
my_linked_list.delete_node(node4)
my_linked_list.delete_node(node2)
self.assertEqual(my_linked_list.length, 0)
self.assertEqual(my_linked_list.head, None)
self.assertEqual(my_linked_list.tail, None)
def test_add_last_one_item():
linked_list = LinkedList()
linked_list.add_last(1)
assert len(linked_list) == 1
assert linked_list.head == 1
assert linked_list.tail == 1
def test_container():
linked_list = LinkedList()
linked_list.add_last(1)
linked_list.add_last(2)
assert 1 in linked_list
assert 2 in linked_list
assert 3 not in linked_list
def test_remove_first_with_one_item():
linked_list = LinkedList()
linked_list.add_last(1)
linked_list.remove_first()
assert len(linked_list) == 0
assert linked_list.head is None
assert linked_list.tail is None
def test_add_last_two_items():
linked_list = LinkedList()
linked_list.add_last(1)
linked_list.add_last(2)
assert len(linked_list) == 2
assert linked_list.head == 1
assert linked_list.tail == 2
assert linked_list.tail.next_ is None
def test_iteration():
linked_list = LinkedList()
linked_list.add_last(1)
linked_list.add_last(2)
linked_list.add_last(3)
values_list = [item for item in linked_list]
assert values_list == [1, 2, 3]
def test_remove_first_with_two_items():
linked_list = LinkedList()
linked_list.add_last(1)
linked_list.add_last(2)
linked_list.remove_first()
assert len(linked_list) == 1
assert linked_list.head == 2
assert linked_list.tail == 2
def test_iteration_of_nodes(self):
node1 = LinkedListNode("node 1")
node2 = LinkedListNode("node 2")
node3 = LinkedListNode("node 3")
my_linked_list = LinkedList()
my_linked_list.add_first(node1)
my_linked_list.add_last(node2)
my_linked_list.add_last(node3)
counter = 0
for node in my_linked_list:
self.assertEqual(node, my_linked_list.get_node_by_index(counter))
counter += 1
def test_get_node_by_index(self):
node1 = LinkedListNode("node 1")
node2 = LinkedListNode("node 2")
my_linked_list = LinkedList()
my_linked_list.add_first(node1)
my_linked_list.add_last(node2)
print(my_linked_list)
with self.assertRaises(IndexError):
my_linked_list.get_node_by_index(2)
self.assertEqual(
my_linked_list.get_node_by_index(0).node_value, 'node 1')
self.assertEqual(
my_linked_list.get_node_by_index(1).node_value, 'node 2')
def test_find_node_by_value(self):
node1 = LinkedListNode("node 1")
node2 = LinkedListNode("node 2")
node3 = LinkedListNode("node 3")
my_linked_list = LinkedList()
my_linked_list.add_first(node1)
my_linked_list.add_node_after(node1, node2)
my_linked_list.add_last(node3)
node_to_find = my_linked_list.find_node_by_value("node 1")
self.assertEqual(node_to_find, node1)
node_to_find = my_linked_list.find_node_by_value("node 2")
self.assertEqual(node_to_find, node2)
node_to_find = my_linked_list.find_node_by_value("node 3")
self.assertEqual(node_to_find, node3)
class Queue:
def __init__(self):
self._list = LinkedList()
def __len__(self) -> int:
return len(self._list)
def __iter__(self) -> Generator[T]:
yield from self._list
def enqueue(self, data: T) -> None:
self._list.add_last(data)
def peek(self) -> T:
if len(self) == 0:
raise IndexError("peek from empty queue")
return self._list.head.data
def dequeue(self) -> T:
if len(self) == 0:
raise IndexError("dequeue from empty queue")
data = self.peek()
self._list.remove_first()
return data
