def append(self, item): if self.storage.length == self.capacity: if self.wildcard == self.storage.tail: self.storage.remove_from_head() self.storage.add_to_head(item) self.wildcard = self.storage.head else: value = ListNode(item) value.prev = self.wildcard.next.prev value.next = self.wildcard.next.next if self.wildcard.prev: self.wildcard.prev = value if self.wildcard.next: self.wildcard.next = value if self.wildcard.next.next: self.wildcard.next.next.prev = value if value and value.next is None: self.storage.tail = value self.wildcard = self.wildcard.next else: self.wildcard = self.wildcard.next # self.wildcard = self.storage.tail # if self.wildcard.next is None: # wildcard = self.storage.head # else: # wildcard = self.wildcard.next # wildcard.prev.next = item # wildcard.next.prev = item return self.storage.add_to_tail(item) self.wildcard = self.storage.tail
def enqueue(self, value): if self.last is None: self.head = ListNode(value) self.last = self.head self.size += 1 else: self.last.next = ListNode(value) self.last.next.prev = self.last self.last = self.last.next self.size += 1
def enqueue(self, value): new_node = ListNode(value) self.size += 1 if not self.head and not self.tail: self.head = new_node self.tail = new_node else: new_node.prev = self.tail self.tail.next = new_node self.tail = new_node
def test_node_delete(self): node_1 = ListNode(3) node_2 = ListNode(4) node_3 = ListNode(5) node_1.next = node_2 node_2.next = node_3 node_2.prev = node_1 node_3.prev = node_2 self.dll.delete(node_2) self.assertEqual(node_1.next, node_3) self.assertEqual(node_3.prev, node_1)
def set(self, key, value): if key not in self.storagedict.keys(): if len(self) == self.limit: dropme = self.tail print("dropping ", dropme) self.storagedict = {k:v for k, v in self.storagedict.items() if v != dropme} self.remove_from_tail() node = ListNode(value) node.id = key print("setting ", node.id) else: print(key, "already in storage") node = self.storagedict[key] self.move_to_front(node) self.storagedict[key] = node
def set(self, key, value): """ Adds the given key-value pair to the cache. The newly- added pair should be considered the most-recently used entry in the cache. If the cache is already at max capacity before this entry is added, then the oldest entry in the cache needs to be removed to make room. Additionally, in the case that the key already exists in the cache, we simply want to overwrite the old value associated with the key with the newly-specified value. """ if key in self.memo: node = self.memo[key] node.value = (key, value) self.queue.move_to_end(node) return node = ListNode((key, value)) self.memo[key] = node self.queue.move_to_end(node) self.queue.length += 1 if self.queue.length > self.limit: value_ = self.queue.remove_from_head() self.memo.pop(value_[0], None) self.queue.length -= 1
def enqueue(self, value): self.length += 1 if not self.head and not self.tail: self.head = self.tail = ListNode(value) else: self.tail.insert_after(value) self.tail = self.tail.next
def push(self, value): self.height += 1 if self.top: self.top.insert_after(value) self.top = self.top.next else: self.top = ListNode(value)
def set(self, key, value): if key in self.storage: self.storage[key] = value #move the node to the front current_node = self.dlist.head while current_node != None: if current_node.value == key: break else: current_node = current_node.next else: #checks if cache is empty if self.current == 0: #creates a new doubly linked list self.dlist = DoublyLinkedList(ListNode(key)) #adds the key value pair to the dictionary self.storage[key] = value self.current += 1 #check if cache is full elif self.current == self.limit: #removes tail from the doubly linked list removedKey = self.dlist.remove_from_tail() #removes key and value from dictionary del self.storage[removedKey] #adds key to the front of the doubly linked list self.dlist.add_to_head(key) #adds the key value pair to the dictionary self.storage[key] = value else: #adds key to the front of the doubly linked list self.dlist.add_to_head(key) #adds the key value pair to the dictionary self.storage[key] = value self.current += 1
def add_n_elements_delete_half_random(n): # Don't time initialization big_arr = array(n) small_arr = array(1) node = ListNode(1) dll = DoublyLinkedList(node) # Experiment with this. # How does higher or lower change things? divisor = 10 # Array size N start = timer() for i in range(n): array_append(big_arr, random.randrange(n / divisor)) for i in range(int(n / 2)): array_remove(big_arr, random.randrange(n / divisor)) time = timer() - start print("Size N Array: Appended " + str(n) + " elements and removed half in " + str(time)) # Array size 1 (To start) start = timer() for i in range(n): array_append(small_arr, random.randrange(int(n / divisor))) for i in range(int(n / 2)): array_remove(small_arr, random.randrange(int(n / divisor))) time = timer() - start print("Size 1 Array: Appended " + str(n) + " elements and removed half in " + str(time)) # Linked List - Head start = timer() for i in range(n): dll.add_to_head(random.randrange(int(n / divisor))) for i in range(int(n / 2)): dll.find_and_delete(random.randrange(int(n / divisor))) time = timer() - start print("Linked Head: Added " + str(n) + " elements and removed half in " + str(time)) # Linked List - Tail start = timer() for i in range(n): dll.add_to_tail(random.randrange(int(n / divisor))) for i in range(int(n / 2)): dll.find_and_delete(random.randrange(int(n / divisor))) time = timer() - start print("Linked Tail: Added " + str(n) + " elements and removed half in " + str(time))
def get(self, key): try: value = self.dict.pop(key) node = ListNode(key) self.storage.move_to_end(node) self.dict[key] = value return value except KeyError: return
def set(self, key, value): if key in self.hash: self.storage.move_to_front(self.hash[key]) self.get(key) if self.size < self.limit: self.storage.add_to_head(ListNode(value)) self.size += 1 self.hash[key] = ListNode(value) if self.size >= self.limit: temp = { key: val for key, val in self.hash.items() if val.value != self.storage.tail.value.value } self.hash = temp del temp self.storage.remove_from_tail() self.storage.add_to_head(ListNode(value)) self.hash[key] = ListNode(value)
def set(self, key, value): if key in self.storage.keys(): self.storage[key] = ListNode(value) else: if self.cache.length < self.limit: self.cache.add_to_head(value) self.storage[key] = self.cache.head elif self.cache.length >= self.limit: self.cache.tail.value = None self.cache.remove_from_tail() self.cache.add_to_head(value) self.storage[key] = self.cache.head
def set(self, key, value): if self.storage.get(key): node = self.storage[key] node.value = (key, value) self.dll.move_to_front(node) else: node = ListNode((key, value)) self.dll.add_to_head(node) self.storage[node.value[0]] = node print(self.storage) if len(self.storage) > self.limit: node = self.dll.remove_from_tail() print(f"In set function: {node}") self.storage[node.value[0]] = None self.dll.delete(node)
def append(self, item): if self.length < self.capacity: self.storage.add_to_tail(item) self.current = self.storage.tail self.length += 1 elif self.current == self.storage.tail: self.storage.remove_from_head() self.storage.add_to_head(item) self.current = self.storage.head else: new_node = ListNode(item, self.current, self.current.next) self.current.next.prev = new_node self.current.next = new_node self.storage.delete(new_node.next) self.current = new_node self.storage.length += 1
def add_n_elements(n): # Don't time initialization big_arr = array(n) small_arr = array(1) node = ListNode(1) dll = DoublyLinkedList(node) # Array size N start = timer() for i in range(n): array_append(big_arr, "value") time = timer() - start print("Size N Array: Appended " + str(n) + " elements in " + str(time)) # Array size 1 (To start) start = timer() for i in range(n): array_append(small_arr, "value") time = timer() - start print("Size 1 Array: Appended " + str(n) + " elements in " + str(time)) # Linked List - Head start = timer() for i in range(n): dll.add_to_head("value") time = timer() - start print("Linked Head: Added " + str(n) + " elements in " + str(time)) # Linked List - Tail start = timer() for i in range(n): dll.add_to_tail("value") time = timer() - start print("Linked Tail: Added " + str(n) + " elements in " + str(time))
def set(self, key, value): if len(self.cache.keys()) == 0: #If this is the first item in cache self.keyChain = DoublyLinkedList(ListNode(key)) self.cache[key] = value elif key in self.cache.keys(): #Else If this key is already in cache self.cache[key] = value current = self.keyChain.head while current.value != key: current = current.next self.keyChain.move_to_end(current) elif len(self.cache.keys()) == self.limit: #Else If the cache is at its limits del self.cache[self.keyChain.head.value] self.keyChain.remove_from_head() self.keyChain.add_to_tail(key) self.cache[key] = value else: #Else Neither of the above conditions are true #IE. Not first item in cache, key not already in cache, and the cache has not reached the limit self.keyChain.add_to_tail(key) self.cache[key] = value
def push(self, value): self.storage.add_to_tail(ListNode(value)) self.size += 1
class DoublyLinkedListTests(unittest.TestCase): def setUp(self): self.node = ListNode(1) self.dll = DoublyLinkedList(self.node) def test_list_remove_from_tail(self): self.dll.add_to_tail(33) self.assertEqual(self.dll.remove_from_tail(), 33) self.dll.add_to_tail(68) self.assertEqual(self.dll.remove_from_tail(), 68) def test_list_remove_from_head(self): self.dll.add_to_head(2) self.assertEqual(self.dll.remove_from_head(), 2) self.dll.add_to_head(55) self.assertEqual(self.dll.remove_from_head(), 55) def test_list_add_to_tail(self): self.dll.add_to_tail(30) self.assertEqual(self.dll.tail.value, 30) self.dll.add_to_tail(20) self.assertEqual(self.dll.tail.value, 20) def test_node_delete(self): # node_1 = ListNode(3) # node_2 = ListNode(4) # node_3 = ListNode(5) # node_1.next = node_2 # node_2.next = node_3 # node_2.prev = node_1 # node_3.prev = node_2 # node_2.delete() # implement test for dll.delete() self.dll.add_to_tail(3) node_1 = self.dll.tail self.dll.add_to_tail(4) node_2 = self.dll.tail self.dll.add_to_tail(5) node_3 = self.dll.tail # test position of node_2 before deletion self.assertEqual(node_1.next, node_2) self.assertEqual(node_3.prev, node_2) self.dll.delete(node_2) self.assertEqual(node_1.next, node_3) self.assertEqual(node_3.prev, node_1) def test_node_insert_before(self): self.node.insert_before(0) self.assertEqual(self.node.prev.value, 0) def test_list_add_to_head(self): self.assertEqual(self.dll.head.value, 1) self.dll.add_to_head(10) self.assertEqual(self.dll.head.value, 10) self.assertEqual(self.dll.head.next.value, 1) def test_node_insert_after(self): self.node.insert_after(2) self.assertEqual(self.node.next.value, 2) def test_list_move_to_end(self): self.dll.add_to_head(40) self.assertEqual(self.dll.tail.value, 1) self.assertEqual(self.dll.head.value, 40) self.dll.move_to_end(self.dll.head) self.assertEqual(self.dll.tail.value, 40) self.assertEqual(self.dll.tail.prev.value, 1) def test_list_move_to_front(self): self.dll.add_to_tail(3) self.assertEqual(self.dll.head.value, 1) self.assertEqual(self.dll.tail.value, 3) self.dll.move_to_front(self.dll.tail) self.assertEqual(self.dll.head.value, 3) self.assertEqual(self.dll.head.next.value, 1) def test_get_max(self): # clear dll to pass first test self.dll.delete(self.dll.head) self.assertIsNone(self.dll.get_max()) self.dll.add_to_tail(100) self.assertEqual(self.dll.get_max(), 100) self.dll.add_to_tail(55) self.assertEqual(self.dll.get_max(), 100) self.dll.add_to_tail(101) self.assertEqual(self.dll.get_max(), 101)
def push(self, value): self.size += 1 return self.storage.add_to_head(ListNode(value))
def set(self, key, value): if not key in self.cache: self.cache[key] = value self.dll.add_to_head(key) else: self.cache[key] = value node = ListNode(value) self.dll.move_to_front(node) if self.dll.length > self.limit: del self.cache[self.dll.tail.value] self.dll.remove_from_tail() # class example # class LRUCache: # """ # Our LRUCache class keeps track of the max number of nodes it # can hold, the current number of nodes it is holding, a doubly- # linked list that holds the key-value entries in the correct # order, as well as a storage dict that provides fast access # to every node stored in the cache. # """ # def __init__(self, limit=10): # self.limit = limit # self.size = 0 # self.storage = {} # self.order = DoublyLinkedList() # def get(self, key): # # if key is in storage # if key in self.storage: # node = self.storage[key] # self.order.move_to_end(node) # return node.value[1] # else: # return None # def set(self, key): # # check and see if they key is in the dict # if key is self.storage: # # if it is # node = self.storage[key] # # overwrite the value # node.value = (key, value) # # move it to the end # self.order.move_to_end(node) # return # # check and see if cache is full # if self.size == self.limit: # # remove oldest entry from dictionary # del self.storage[self.order.head.value[0]] # # and LL # self.order.remove_from_head() # self.size -= 1 # # add to the LL (key, value) # self.order.add_to_tail((key, value)) # # add the key and value to the dict # self.storage[key] = self.order.tail # # increment size # self.size += 1
def create_doubly_linked_list_numbers(): dll = DoublyLinkedList(ListNode(1)) for i in range(2, 100000): dll.add_to_tail(i) return dll
def enqueue(self, value): self.size += 1 return self.storage.add_to_tail(ListNode(value))
class DoublyLinkedListTests(unittest.TestCase): def setUp(self): self.node = ListNode(1) self.dll = DoublyLinkedList(self.node) def test_list_remove_from_tail(self): self.dll.remove_from_tail() self.assertIsNone(self.dll.head) self.assertIsNone(self.dll.tail) self.assertEqual(len(self.dll), 0) self.dll.add_to_tail(33) self.assertEqual(self.dll.head.value, 33) self.assertEqual(self.dll.tail.value, 33) self.assertEqual(len(self.dll), 1) self.assertEqual(self.dll.remove_from_tail(), 33) self.assertEqual(len(self.dll), 0) self.dll.add_to_tail(68) self.assertEqual(len(self.dll), 1) self.assertEqual(self.dll.remove_from_tail(), 68) self.assertEqual(len(self.dll), 0) def test_list_remove_from_head(self): self.dll.remove_from_head() self.assertIsNone(self.dll.head) self.assertIsNone(self.dll.tail) self.assertEqual(len(self.dll), 0) self.dll.add_to_head(2) self.assertEqual(self.dll.head.value, 2) self.assertEqual(self.dll.tail.value, 2) self.assertEqual(len(self.dll), 1) self.assertEqual(self.dll.remove_from_head(), 2) self.assertEqual(len(self.dll), 0) self.dll.add_to_head(55) self.assertEqual(len(self.dll), 1) self.assertEqual(self.dll.remove_from_head(), 55) self.assertEqual(len(self.dll), 0) def test_list_add_to_tail(self): self.assertEqual(self.dll.tail.value, 1) self.assertEqual(len(self.dll), 1) self.dll.add_to_tail(30) self.assertEqual(self.dll.tail.prev.value, 1) self.assertEqual(self.dll.tail.value, 30) self.assertEqual(len(self.dll), 2) self.dll.add_to_tail(20) self.assertEqual(self.dll.tail.prev.value, 30) self.assertEqual(self.dll.tail.value, 20) self.assertEqual(len(self.dll), 3) def test_node_delete(self): node_1 = ListNode(3) node_2 = ListNode(4) node_3 = ListNode(5) node_1.next = node_2 node_2.next = node_3 node_2.prev = node_1 node_3.prev = node_2 node_2.delete() self.assertEqual(node_1.next, node_3) self.assertEqual(node_3.prev, node_1) def test_node_insert_before(self): self.node.insert_before(0) self.assertEqual(self.node.prev.value, 0) def test_list_add_to_head(self): self.assertEqual(self.dll.head.value, 1) self.dll.add_to_head(10) self.assertEqual(self.dll.head.value, 10) self.assertEqual(self.dll.head.next.value, 1) self.assertEqual(len(self.dll), 2) def test_node_insert_after(self): self.node.insert_after(2) self.assertEqual(self.node.next.value, 2) def test_list_move_to_end(self): self.dll.add_to_head(40) self.assertEqual(self.dll.tail.value, 1) self.assertEqual(self.dll.head.value, 40) self.dll.move_to_end(self.dll.head) self.assertEqual(self.dll.tail.value, 40) self.assertEqual(self.dll.tail.prev.value, 1) self.assertEqual(len(self.dll), 2) self.dll.add_to_tail(4) self.dll.move_to_end(self.dll.head.next) self.assertEqual(self.dll.tail.value, 40) self.assertEqual(self.dll.tail.prev.value, 4) self.assertEqual(len(self.dll), 3) def test_list_move_to_front(self): self.dll.add_to_tail(3) self.assertEqual(self.dll.head.value, 1) self.assertEqual(self.dll.tail.value, 3) self.dll.move_to_front(self.dll.tail) self.assertEqual(self.dll.head.value, 3) self.assertEqual(self.dll.head.next.value, 1) self.assertEqual(len(self.dll), 2) self.dll.add_to_head(29) self.dll.move_to_front(self.dll.head.next) self.assertEqual(self.dll.head.value, 3) self.assertEqual(self.dll.head.next.value, 29) self.assertEqual(len(self.dll), 3) def test_list_delete(self): self.dll.delete(self.node) self.assertIsNone(self.dll.head) self.assertIsNone(self.dll.tail) self.assertEqual(len(self.dll), 0) self.dll.add_to_tail(1) self.dll.add_to_head(9) self.dll.add_to_tail(6) self.dll.delete(self.dll.head) self.assertEqual(self.dll.head.value, 1) self.assertEqual(self.dll.tail.value, 6) self.assertEqual(len(self.dll), 2) self.dll.delete(self.dll.head) self.assertEqual(self.dll.head.value, 6) self.assertEqual(self.dll.tail.value, 6) self.assertEqual(len(self.dll), 1) def test_get_max(self): self.assertEqual(self.dll.get_max(), 1) self.dll.add_to_tail(100) self.assertEqual(self.dll.get_max(), 100) self.dll.add_to_tail(55) self.assertEqual(self.dll.get_max(), 100) self.dll.add_to_tail(101) self.assertEqual(self.dll.get_max(), 101)
class DoublyLinkedListTests(unittest.TestCase): def setUp(self): self.node = ListNode(1) self.dll = DoublyLinkedList(self.node) def test_list_remove_from_tail(self): self.dll.add_to_tail(33) self.assertEqual(self.dll.remove_from_tail(), 33) self.dll.add_to_tail(68) self.assertEqual(self.dll.remove_from_tail(), 68) def test_list_remove_from_head(self): self.dll.add_to_head(2) self.assertEqual(self.dll.remove_from_head(), 2) self.dll.add_to_head(55) self.assertEqual(self.dll.remove_from_head(), 55) def test_list_add_to_tail(self): self.dll.add_to_tail(30) self.assertEqual(self.dll.tail.value, 30) self.dll.add_to_tail(20) self.assertEqual(self.dll.tail.value, 20) def test_node_delete(self): node_1 = ListNode(3) node_2 = ListNode(4) node_3 = ListNode(5) node_1.next = node_2 node_2.next = node_3 node_2.prev = node_1 node_3.prev = node_2 node_2.delete() self.assertEqual(node_1.next, node_3) self.assertEqual(node_3.prev, node_1) def test_node_insert_before(self): self.node.insert_before(0) self.assertEqual(self.node.prev.value, 0) def test_list_add_to_head(self): self.assertEqual(self.dll.head.value, 1) self.dll.add_to_head(10) self.assertEqual(self.dll.head.value, 10) self.assertEqual(self.dll.head.next.value, 1) def test_node_insert_after(self): self.node.insert_after(2) self.assertEqual(self.node.next.value, 2) def test_list_move_to_end(self): self.dll.add_to_head(40) self.assertEqual(self.dll.tail.value, 1) self.assertEqual(self.dll.head.value, 40) self.dll.move_to_end(self.dll.head) self.assertEqual(self.dll.tail.value, 40) self.assertEqual(self.dll.tail.prev.value, 1) def test_list_move_to_front(self): self.dll.add_to_tail(3) self.assertEqual(self.dll.head.value, 1) self.assertEqual(self.dll.tail.value, 3) self.dll.move_to_front(self.dll.tail) self.assertEqual(self.dll.head.value, 3) self.assertEqual(self.dll.head.next.value, 1) def test_get_max(self): # changed the test to be an assertEqual instead of assertIsNone # the list is built with a initial '1' so this test should not # through none, it should show the single element self.assertEqual(self.dll.get_max(), 1) self.dll.add_to_tail(100) self.assertEqual(self.dll.get_max(), 100) self.dll.add_to_tail(55) self.assertEqual(self.dll.get_max(), 100) self.dll.add_to_tail(101) self.assertEqual(self.dll.get_max(), 101)
def test_node_delete(self): print(" 4---in test_node_delete---") node_1 = ListNode(3) node_2 = ListNode(4) node_3 = ListNode(5) node_1.next = node_2 node_2.next = node_3 node_2.prev = node_1 node_3.prev = node_2 node_2.delete() self.assertEqual(node_1.next, node_3) self.assertEqual(node_3.prev, node_1) print("----out of test_node_delete----") print("-------------------------------")
def setUp(self): self.node = ListNode(1) self.dll = DoublyLinkedList(self.node)
def test_node_delete(self): node_1 = ListNode(3) node_2 = ListNode(4) node_3 = ListNode(5) node_1.next = node_2 node_2.next = node_3 node_2.prev = node_1 node_3.prev = node_2 # VERY INTERESTING SYNTAX HERE vvv node_2.delete() self.assertEqual(node_1.next, node_3) self.assertEqual(node_3.prev, node_1)