class Queue:
def __init__(self, size=0):
self.size = size
# Why is our DLL a good choice to store our elements?
self.storage = DoublyLinkedList()
def enqueue(self, value):
self.storage.add_to_tail(value)
self.size += 1
# print(f"added {self.storage.tail.value} to queue's tail")
def dequeue(self):
if self.storage.head is None:
return None
self.size -= 1
return self.storage.remove_from_head()
def len(self):
return self.size
class Stack:
def __init__(self, size=0):
self.size = size
# Why is our DLL a good choice to store our elements?
self.storage = DoublyLinkedList()
def push(self, value):
#adding to head is expensive for a singly linked list, but for doubly linked
#list it is an identical process
self.storage.add_to_tail(value)
self.size += 1
# print(f"added {self.storage.tail.value} to the stack's tail")
def pop(self):
if self.storage.head is None:
return None
self.size -= 1
return self.storage.remove_from_tail()
def len(self):
return self.size
def setUp(self):
self.node = ListNode(1)
self.dll = DoublyLinkedList(self.node)
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)
def __init__(self, size=0):
self.size = size
# Why is our DLL a good choice to store our elements?
self.storage = DoublyLinkedList()
def __init__(self, limit=10):
self.limit = limit
self.storage = {}
self.order = DoublyLinkedList()
self.size = 0
class LRUCache:
def __init__(self, limit=10):
self.limit = limit
self.storage = {}
self.order = DoublyLinkedList()
self.size = 0
def __len__(self):
return self.size
def report(self):
values = []
current_node = self.order.head
while current_node.value:
values.append(current_node.value)
if current_node.next:
current_node = current_node.next
else:
break
print(str(values))
print("My DLL's head: " + str(self.order.head.value))
if self.order.head.next:
print("My DLL's head.next: " + str(self.order.head.next.value))
else:
print("No head.next")
print("My DLL's tail: " + str(self.order.tail.value))
print("My DLL's length: " + str(self.order.length) + "\n")
def modified_set(self, key, value):
value_combo = (key, value)
if key in self.storage:
node = self.storage[key]
# overwrite the old value
node.value = value_combo
# move this node to the tail
self.order.move_to_end(node)
return
if len(self.storage) == self.limit:
node = self.order.head
self.order.delete(node)
del self.storage[node.value[0]]
self.order.add_to_tail(value_combo)
self.storage[key] = self.order.tail
def set(self, key, value):
# I'm going to rename your 'value' variable to be 'value_combo' to keep things straight.
value_combo = (key, value)
# So, ignore the line below now.
# value = (key, value)
if key in self.storage:
# Here, you need to update the value of the node, not what the dictionary is holding.
# The value that the dictionary holds is the node, and it will be updated as soon as you update the node.
# So, instead of what you have on line 59, we'll update the node on line 60.
# self.storage[key] = value
node = self.storage[key]
node.value = value_combo
# Now, you already have the node, so you don't need to loop through to find it.
'''
node = self.order.head
while node:
if node.value == value:
self.order.move_to_tail(node)
return
else:
node = node.next
'''
# Just move it to the tail and return
self.order.move_to_end(node)
return
if len(self.storage) == self.limit:
node = self.order.head
self.order.delete(node)
del self.storage[node.value[0]]
self.order.add_to_tail(value_combo)
# Okay, so here you don't want to set the value of the key-value pair to be the tuple.
# So, no self.storage[key] = value_combo
# You need it to be the node, which is conveniently the tail.
self.storage[key] = self.order.tail
def get(self, key):
if key not in self.storage:
return None
# On the next line of code, your 'value' variable is the node,
# so you don't have to loop through the DLL list to find it.
# You can move it to the end right away.
value = self.storage[key]
self.order.move_to_end(value)
'''
node = self.order.head
while node:
if node.value == value:
self.order.move_to_end(node)
break
node = node.next
'''
# So we need to access 'value' (AKA the node)'s value[1] to get the actual value to return. So many values! :-)
return value.value[1]