def test_add_one_item(self): linked_list = DoublyLinkedList() linked_list.add(1) self.assertEqual(linked_list.head.value, 1) self.assertEqual(linked_list.head.previous, None) self.assertEqual(linked_list.tail.value, 1) self.assertEqual(linked_list.tail.previous, None)
def test_remove_item_not_in_list(self): linked_list = DoublyLinkedList() linked_list.add(2) linked_list.add(4) linked_list.add(25) linked_list.add(20) linked_list.add(12) self.assertEqual(linked_list.remove(0), False) self.assertEqual(linked_list.walk(), [2, 4, 25, 20, 12])
def test_remove_from_tail(self): linked_list = DoublyLinkedList() linked_list.add(2) linked_list.add(4) linked_list.add(25) linked_list.add(20) linked_list.add(12) self.assertEqual(linked_list.remove(12), True) self.assertEqual(linked_list.tail.next, None) self.assertEqual(linked_list.walk(), [2, 4, 25, 20])
def test_remove_from_middle(self): linked_list = DoublyLinkedList() linked_list.add(2) linked_list.add(4) linked_list.add(25) linked_list.add(20) linked_list.add(12) self.assertEqual(linked_list.remove(25), True) self.assertEqual(linked_list.head.next.next.previous.value, 4) self.assertEqual(linked_list.walk(), [2, 4, 20, 12])
def test_remove_from_head(self): linked_list = DoublyLinkedList() linked_list.add(2) linked_list.add(4) linked_list.add(25) linked_list.add(20) linked_list.add(12) self.assertEqual(linked_list.remove(2), True) self.assertEqual(linked_list.head.previous, None) self.assertEqual(linked_list.walk(), [4, 25, 20, 12])
def test_walk_reverse(self): linked_list = DoublyLinkedList() linked_list.add(2) linked_list.add(4) linked_list.add(25) linked_list.add(20) linked_list.add(12) self.assertEqual(linked_list.walk_reverse(), [12, 20, 25, 4, 2])
def test_walk(self): linked_list = DoublyLinkedList() linked_list.add(2) linked_list.add(4) linked_list.add(25) linked_list.add(20) linked_list.add(12) self.assertEqual(linked_list.walk(), [2, 4, 25, 20, 12])
def test_search_item_at_tail(self): linked_list = DoublyLinkedList() linked_list.add(2) linked_list.add(4) linked_list.add(25) linked_list.add(20) linked_list.add(12) self.assertEqual(linked_list.search(12), True)
def test_search_item_not_in_list(self): linked_list = DoublyLinkedList() linked_list.add(2) linked_list.add(4) linked_list.add(25) linked_list.add(52) linked_list.add(20) linked_list.add(12) self.assertEqual(linked_list.search(0), False)
class LRUCache: def __init__(self, limit=10): self.limit = limit self.length = 0 self.storage = DoublyLinkedList() """ Retrieves the value associated with the given key. Also needs to move the key-value pair to the end of the order such that the pair is considered most-recently used. Returns the value associated with the key or None if the key-value pair doesn't exist in the cache. """ def get(self, key): current = self.storage.head while current is not None: if current.value[0] == key: self.storage.move_to_front(current) return current.value[1] current = current.next return None """ 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. """ def set(self, key, value): current = self.storage.head replaced = False while current is not None and replaced is not True: if current.value[0] == key: current.value[1] = value self.storage.move_to_front(current) replaced = True current = current.next if self.length == self.limit and replaced is not True: self.storage.remove_from_tail() self.storage.add_to_head([key, value]) elif replaced is not True: self.storage.add_to_head([key, value]) self.length = self.storage.length
class Queue: def __init__(self): self.size = 0 # Why is our DLL a good choice to store our elements? # self.storage = ? self.storage = DoublyLinkedList() def enqueue(self, value): self.storage.add_to_tail(value) self.size += 1 def dequeue(self): if self.size > 0: self.size -= 1 return self.storage.remove_from_head() else: return None def len(self): return self.size
class Stack: def __init__(self): self.size = 0 # Why is our DLL a good choice to store our elements? # self.storage = ? self.storage = DoublyLinkedList() def push(self, value): self.size += 1 self.storage.add_to_head(value) def pop(self): if self.len() > 0: self.size -= 1 return self.storage.remove_from_head() else: return None def len(self): return len(self.storage)
class Queue: def __init__(self): self.size = 0 # what data structure should we # use to store queue elements? self.storage = DoublyLinkedList() def enqueue(self, item): self.storage.add_to_tail(item) self.size += 1 def dequeue(self): item = self.storage.remove_from_head() if item: self.size -= 1 return item else: return None def len(self): return self.size
class Queue: def __init__(self): self.size = 0 # Why is our DLL a good choice to store our elements? # self.storage = ? self.dll = DoublyLinkedList() def enqueue(self, value): self.dll.add_to_head(value) self.size += 1 def dequeue(self): if self.size == 0: pass else: self.size -= 1 value = self.dll.remove_from_tail() return value def len(self): return self.size
def test_prepend(self): linked_list = DoublyLinkedList() linked_list.add(1) linked_list.prepend(20) self.assertEqual(linked_list.head.value, 20) self.assertEqual(linked_list.tail.value, 1) self.assertEqual(linked_list.tail.previous, linked_list.head)
class Stack: def __init__(self): self.size = 0 # Why is our DLL a good choice to store our elements? # self.storage = ? self.dll = DoublyLinkedList() def push(self, value): self.size += 1 self.dll.add_to_tail(value) def pop(self): if self.size == 0: return else: self.size -= 1 value = self.dll.remove_from_tail() return value def len(self): return self.size
def test_add_two_items(self): linked_list = DoublyLinkedList() linked_list.add(1) linked_list.add(22) self.assertEqual(linked_list.head.next.value, 22) self.assertEqual(linked_list.head.next, linked_list.tail) self.assertEqual(linked_list.head.previous, None) self.assertEqual(linked_list.tail.previous, linked_list.head)
class LRUCache: def __init__(self, limit=10): self.limit = limit self.entries = {} self.cache = DoublyLinkedList() """ Retrieves the value associated with the given key. Also needs to move the key-value pair to the top of the order such that the pair is considered most-recently used. Returns the value associated with the key or None if the key-value pair doesn't exist in the cache. """ def get(self, key): try: node, value = self.entries[key] self.cache.move_to_front(node) return value except KeyError: return None """ 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. """ def set(self, key, value): try: self.entries[key][1] = value self.cache.move_to_front(self.entries[key][0]) except KeyError: if len(self.entries) == self.limit: key_to_remove = self.cache.remove_from_tail() self.entries.pop(key_to_remove) node = self.cache.add_to_head(key) self.entries[key] = [node, value] """ Method added for testing purposes. Prints all the elements in the cache in their current order. """ def print_cache(self): cache = [] pointer = self.cache.head while pointer: cache.append(pointer.value) pointer = pointer.next print(cache)
def __init__(self, init=None): self.contents = DoublyLinkedList() # check if an init string is provided # if so, put the contents of the init string in self.contents if init: pass
def __init__(self, limit=10): self.limit = limit self.length = 0 self.storage = DoublyLinkedList()
from doubly_linked_list.doubly_linked_list import DoublyLinkedList linked_list = DoublyLinkedList() linked_list.add(2) linked_list.add(4) linked_list.add(25) linked_list.add(20) linked_list.add(12) print(linked_list.walk()) linked_list.remove(20) print(linked_list.walk()) print(linked_list.head.next.value, linked_list.tail.previous.value)
def test_walk_list_empty(self): linked_list = DoublyLinkedList() self.assertEqual(linked_list.walk(), [])
def __init__(self, limit=10): self.limit = limit self.entries = {} self.cache = DoublyLinkedList()
def __init__(self): self.size = 0 # Why is our DLL a good choice to store our elements? # self.storage = ? self.dll = DoublyLinkedList()
def test_empty_list(self): linked_list = DoublyLinkedList() self.assertEqual(linked_list.head, None) self.assertEqual(linked_list.tail, None)
def __init__(self): self.size = 0 # what data structure should we # use to store queue elements? self.storage = DoublyLinkedList()
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.length = 0 self.order_list = DoublyLinkedList() self.storage = {} def __len__(self): return self.length """ returns true if the key exists in this cache, false otherwise """ def has_key(self, key): return key in self.storage """ Retrieves the value associated with the given key. Also needs to move the key-value pair to the end of the order such that the pair is considered most-recently used. Returns the value associated with the key or None if the key-value pair doesn't exist in the cache. """ def get(self, key): # check if the key exists if not self.has_key(key) or self.length == 0: return None # find the node with this key node = self.order_list.find_node(key) # move that node to the end of the used-order list self.order_list.move_to_end(node) # return the value return self.storage[key] """ 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. """ def set(self, key, value): if self.has_key(key): # overwriting an existing entry self.storage[key] = value # find existing node and move it to end node = self.order_list.find_node(key) self.order_list.move_to_end(node) else: # creating a new entry self.storage[key] = value # add new node to the end of the list self.order_list.add_to_tail(key) # if we are at the size limit, remove the oldest item if self.length == self.limit: # remove the oldest used entry from both the # order list and storage dict old_key = self.order_list.remove_from_head() del self.storage[old_key] else: # not at the limit, just added the new item self.length += 1