def analyseCountFunctionOfDoublyLinkedList(iterable, word): _sum = 0 doublyLinkedListHistogram = doubly_linked_list.DoublyLinkedList(iterable) for i in range(100): _sum += doublyLinkedListHistogram.find(lambda node: node[0] == word) avg = _sum / 100 return avg
def setUp(self): self.test_list = doubly_linked_list.DoublyLinkedList() for each_number in range(1, 10): self.test_list.insert(each_number) self.test_list_for_one_node = doubly_linked_list.DoublyLinkedList() self.test_list_for_one_node.insert("one node list test data") self.test_list_for_string_data = doubly_linked_list.DoublyLinkedList() self.test_list_for_string_data.insert('TestData') self.test_list_for_string_data.insert(61) self.test_list_for_string_data.insert("Additional Test Data") self.test_list_for_no_nodes = doubly_linked_list.DoublyLinkedList()
def test_remove(): """remove(val) should remove the first node with the given val from the list, wherever it might be if node is not an item in the list, raises IndexError""" dll = d.DoublyLinkedList() dll.insert(1) dll.insert(2) dll.insert(3) with pytest.raises(TypeError): dll.remove() dll.remove("adfe", 5) with pytest.raises(IndexError): dll.remove(8) assert dll.remove(2) is None assert dll.search(2) is None assert dll.search(3).next.content == 1 # i.e., 3 goes to 1 now dll.remove(1) assert dll.head.content == 3 assert dll.tail.content == 3 assert dll.head.next is None assert dll.head is dll.tail assert dll.tail.previous is None dll.remove(3) assert dll.head is None assert dll.tail is None
def analyseGenerationOfDoublyLinkedList(iterable): start_time = time.time() _sum = 0 for i in range(100): histogram = doubly_linked_list.DoublyLinkedList(iterable) _sum += time.time() - start_time avg = _sum / 100 return avg
def test_set_tail_implementation(self): first_node = doubly_linked_list.Node(1) second_node = doubly_linked_list.Node(2) last_node = doubly_linked_list.Node(3) dbLList = doubly_linked_list.DoublyLinkedList() dbLList.setHead(first_node) dbLList.setHead(second_node) dbLList.setTail(last_node) self.assertEqual(dbLList.length, 3)
class LRUCache: ''' LRUCache represents cache with LRU Heuristic ''' capacity = 0 doubly_list = dll.DoublyLinkedList() node_map = {} def __init__(self, capacity): ''' Initliaze the cache with fixed capacity ''' self.capacity = capacity def get(self, key): ''' Get the value of the key if present else -1 ''' if key in self.node_map: node = self.node_map[key] # Delete the Node to move it to front of the list self.doubly_list.delete(node) # Add it back again self.doubly_list.insert(node) return node.pair[1] return -1 def put(self, key, value): ''' Put the key, value pair in the cache, if cache is full, delete the least recently used value ''' if key in self.node_map: node = self.node_map[key] # Delete the Node to move it to front of the list self.doubly_list.delete(node) # Update the value of the node node.pair = (key, value) # Add it back to the Doubly Linked List self.doubly_list.insert(node) self.node_map[key] = node else: # LRU has reached the capacity, so we need to delete the least recently used value if len(self.node_map) == self.capacity: deleted = self.doubly_list.delete_last() self.node_map.pop(deleted.pair[0]) # Add the new value node = dll.Node((key, value)) self.node_map[key] = node self.doubly_list.insert(node) def __repr__(self): return repr(self.doubly_list)
def test_set_head_implementation(self): first_node = doubly_linked_list.Node(1) second_node = doubly_linked_list.Node(2) dbLList = doubly_linked_list.DoublyLinkedList() dbLList.setHead(first_node) dbLList.setHead(second_node) firstNode_Val = dbLList.get(0) secondNode_Val = dbLList.get(1) self.assertEqual(dbLList.length, 2) self.assertEqual(second_node.val, firstNode_Val) self.assertEqual(first_node.val, secondNode_Val)
def test_DoublyLinkedList(self): self.setUp() # This feels pretty superfluous due to setUp, which appears to # be intended to come first, but here it is anyways. # We'll say it's for future-proofing. constructor_test_object = doubly_linked_list.DoublyLinkedList() self.assertTrue( isinstance(constructor_test_object, doubly_linked_list.DoublyLinkedList))
def test_append(): """append(val) will append the value 'val' at the tail of the list""" dll = d.DoublyLinkedList() with pytest.raises(TypeError): dll.append() # returns nothing, we have no way of getting at stuff yet assert dll.append("blaguboo") is None assert dll.head.content == "blaguboo" assert dll.tail.content == "blaguboo" dll.append("one thing") dll.append("second thing") assert dll.tail.content == "second thing" assert dll.head.content == "blaguboo"
def test_insert(): """insert(val) will insert the value 'val' at the head of the list""" dll = d.DoublyLinkedList() with pytest.raises(TypeError): dll.insert() #returns nothing assert dll.insert("blaguboo") is None assert dll.head.content == "blaguboo" assert dll.tail.content == "blaguboo" dll.insert("one thing") dll.insert("second thing") assert dll.head.content == "second thing" assert dll.tail.content == "blaguboo"
def test_shift(): """shift() will remove the last value from the tail of the list and return it.""" dll = d.DoublyLinkedList() with pytest.raises(IndexError) as err: dll.shift() assert "empty" in err.value dll.insert(10) dll.insert(9) assert dll.shift() == 10 assert dll.shift() == 9 assert dll.head is None assert dll.tail is None with pytest.raises(IndexError) as err: dll.pop() assert "empty" in err.value
def test_pop(): '''Should return head data & remove it, raise IndexError if empty''' dll = d.DoublyLinkedList() with pytest.raises(IndexError) as err: dll.pop() assert "empty" in err.value dll.insert(10) dll.insert(9) assert dll.pop() == 9 assert dll.pop() == 10 assert dll.head is None assert dll.tail is None with pytest.raises(IndexError) as err: dll.pop() assert "empty" in err.value
def __init__(self): self.size = 0 self.items = dll.DoublyLinkedList()
def setUp(self): self.list = doubly_linked_list.DoublyLinkedList()
def test_create(): """Should raise TypeError if initialized with data, return a doubly linked list otherwise""" with pytest.raises(TypeError): d.DoublyLinkedList("a") assert isinstance(d.DoublyLinkedList(), d.DoublyLinkedList)
def __init__(self): self.mem = doubly_linked_list.DoublyLinkedList()
def test_empty_list_when_init_doubly_linked_list(self): dbLList = doubly_linked_list.DoublyLinkedList() self.assertEqual(dbLList.length, 0) self.assertEqual(dbLList.head, None) self.assertEqual(dbLList.tail, None)
def test_insert_before_implementation(self): node_insert = doubly_linked_list.Node(1) dbLList = doubly_linked_list.DoublyLinkedList()
def setUp(self): self.SUT = doubly_linked_list.DoublyLinkedList( [4, 1, 6, 0, 12, 7, 13, 5])
# - Traverse. # - Push/Append/Insert nodes. # - Remove by data/index. # - Delete. """ ################################################# # ### Author: Samyuel Danyo # ### Date: 31/05/2020 # ### Last Edit: 31/05/2020 ################################################## # Local Application/Library Specific Imports. import doubly_linked_list as dll ################################################## # Test ################################################## DLLIST = dll.DoublyLinkedList(dll.DLLNode(0)) for i in range(1, 6): DLLIST.insert(i, i) DLLIST.push(-1) DLLIST.append(7) DLLIST.insert_after(DLLIST.head.next, 100) DLLIST.insert(5, 100) DLLIST.traverse() print('=' * 30) DLLIST.remove(100) print(DLLIST) print('=' * 30) DLLIST.remove_node(3) DLLIST.traverse() print('=' * 30) DLLIST.delete()
def __init__(self): self.size = 0 # Why is our DLL a good choice to store our elements? self.storage = doubly_linked_list.DoublyLinkedList()
def __init__(self, array=None): self.linked_list = doubly_linked_list.DoublyLinkedList(array)
def __init__(self): self.size = 0 self.storage = doubly_linked_list.DoublyLinkedList()