def bft_print(self, node):
#PLAN
#create/initialize queue
#add root to queue
#while queue is not empty
#pop head/top item out of queue & into temp variable [node = pop head of queue]
#if temp exists
# if there is temp var on the right
#put that into the queue on the right
# if there is a left temp var
#put that into the queue on the left
# DO the THING!... print temp value
# else break
queue = Queue()
queue.enqueue(node)
while queue.len() != 0:
temp: BinarySearchTree = queue.dequeue()
if temp:
if temp.right:
queue.enqueue(temp.right)
if temp.left:
queue.enqueue(temp.left)
print(temp.value)
else:
break
def bft_print(self, node):
# queue = []
# if node:
# queue.append(node)
# while len(queue) > 0:
# print('val', queue[0].value)
# current_node = queue[0]
# if current_node.left_child:
# queue.append(current_node.left_child)
# if current_node.right_child:
# queue.append(current_node.right_child)
# queue.pop(0)
queue = Queue()
queue.enqueue(node)
while queue.len():
current_node = queue.dequeue()
print(current_node.value)
if current_node.left:
queue.enqueue(current_node.left)
if current_node.right:
queue.enqueue(current_node.right)
class RingBuffer:
def __init__(self, capacity):
self.capacity = capacity
self.current = None
self.storage = DoublyLinkedList()
self.order = Queue()
def append(self, item):
if len(self.storage) == self.capacity:
node = self.order.dequeue()
node.value = item
self.order.enqueue(node)
else:
self.storage.add_to_tail(item)
self.order.enqueue(self.storage.tail)
def get(self):
list_buffer_contents = [''] * len(self.storage)
node = self.storage.head
i = 0
while node:
list_buffer_contents[i] = node.value
i += 1
node = node.next
return list_buffer_contents
def __init__(self, value):
self.value = value
self.left = None
self.right = None
self.queue = Queue()
self.stack = Stack()
self.lastPrintedValue = -math.inf
def bft_print(self, node):
# Initialize a queue
queue = Queue()
# Push root to queue
queue.enqueue(node)
# While stack not empty
while queue.len() > 0:
# Pop item out of queue into temp
current_node = queue.dequeue()
# If temp has right, put into queue
if current_node.right:
# Ram it through method again
queue.enqueue(current_node.right)
# If temp has left, put into queue
if current_node.left:
# Ram it through method again
queue.enqueue(current_node.left)
# Print
print(current_node.value)
def bft_print(self, node):
#So to print every value in bredth
#we use as a queue as we call a node
#we put the child nodes at the back of the queue
#this enforces calling all nodes of one level before the next level of nodes are called
q = Queue()
#enqueue adds a value to the back of the line.
#to start the function we put the node passed in at the back/front of the queue
q.enqueue(node)
#now, while the queue is not empty...
while q.len() > 0:
#we take the node at the front of the queue
#and set it to current node
current_node = q.dequeue()
#print its value
print(current_node.value)
#if there is a node to the left, add it to the queu
if current_node.left:
q.enqueue(current_node.left)
#same for right
if current_node.right:
q.enqueue(current_node.right)
def bft_print(self, node):
# Check if this node is not empty
if node:
# Create a queue
my_queue = Queue()
# enqueue node
my_queue.enqueue(node)
# While the length of my_queue is not 0
while my_queue.len() != 0:
# save the last node in the queue in popped_node
# dequeue this last node from the queue
dequeued_node = my_queue.dequeue()
# print the value of popped_node
print(dequeued_node.value)
# If popped_node.left is not empty
if dequeued_node.left:
# Enqueue popped_node.left to the queue
my_queue.enqueue(dequeued_node.left)
# If popped_node.right is not empty
if dequeued_node.right:
# Enqueue popped_node.right to the queue
my_queue.enqueue(dequeued_node.right)
def bft_print(self, node=None):
q = Queue()
q.enqueue(self)
while q.len() > 0:
node_current = q.dequeue()
print(node_current.value)
if node_current.left:
q.enqueue(node_current.left)
if node_current.right:
q.enqueue(node_current.right)
def bft_print(self, node):
q = Queue()
q.enqueue(node)
while q.len() > 0:
temp = q.dequeue()
print(temp)
if temp.left:
q.enqueue(temp.left)
if temp.right:
q.enqueue(temp.right)
def bft_print(self, node):
q = Queue()
q.enqueue(self)
while q.len() > 0:
current_node = q.dequeue()
if current_node.left:
q.enqueue(current_node.left)
if current_node.right:
q.enqueue(current_node.right)
print(current_node.value)
def bft_print(self, node):
q = Queue()
q.enqueue(self.value)
while q:
q.dequeue()
print(self.value)
if (self.left):
q.enqueue(self.left.value)
if (self.right):
q.enqueue(self.right.value)
def bft_print(self, node):
queue = Queue()
queue.enqueue(node)
while queue.len() > 0:
temp = queue.dequeue()
print(temp.value)
if temp.left:
queue.enqueue(temp.left)
if temp.right:
queue.enqueue(temp.right)
def bft_print(self, node):
queue = Queue()
queue.enqueue(node)
while queue.len() > 0:
current = queue.dequeue()
print(current.value)
if current.left:
queue.enqueue(current.left)
if current.right:
queue.enqueue(current.right)
def for_each(self, cb):
if self.left:
self.left.for_each(cb)
if self.right:
self.right.for_each(cb)
return cb(self.value)
queue = Queue()
queue.enqueue(node)
def bft_print(self, node):
queue = Queue()
queue.enqueue(node)
while queue.len() > 0:
root = queue.dequeue()
print(root.value)
if root.left != None:
queue.enqueue(root.left)
if root.right != None:
queue.enqueue(root.right)
def bft_print(self, node):
queue = Queue()
queue.enqueue(self)
while queue.len() > 0:
node = queue.dequeue()
print(node.value)
if node.left:
queue.enqueue(node.left)
if node.right:
queue.enqueue(node.right)
def bft_print(self, node):
q = Queue()
q.enqueue(self)
while q.len() != 0:
node = q.dequeue()
print(node.value)
if node.left:
q.enqueue(node.left)
if node.right:
q.enqueue(node.right)
def bft_print(self, node):
q = Queue()
q.enqueue(node)
while q.len() > 0:
current_pop = q.dequeue()
print(current_pop.value)
if current_pop.left:
q.enqueue(current_pop.left)
if current_pop.right:
q.enqueue(current_pop.right)
def bft_print(self, node):
q = Queue()
q.enqueue(node)
while q.len() > 0:
t = q.dequeue()
print(t.value)
if t.left:
q.enqueue(t.left)
if t.right:
q.enqueue(t.right)
def bft_print(self, node):
storage = Queue()
storage.enqueue(self)
while storage.len():
current_node = storage.dequeue()
print(current_node.value)
if current_node.left:
storage.enqueue(current_node.left)
if current_node.right:
storage.enqueue(current_node.right)
def bft_print(self, node):
queue = Queue()
queue.enqueue(node)
while queue.len() > 0:
head = queue.dequeue()
print(head.value)
if current_node.left is not None:
queue.enqueue(head.left)
if current_node.right is not None:
queue.enqueue(head.right)
def bft_print(self, node):
"""
Iterative approach notes from lecture
Make a queue
add root to queue
while queue.length > 0
immediately pop root and save to a temp var (temp = queue.dequeue()) - with a queue, popping doesn't have to happen immediately
Do the thing
if temp.left add to queue
if temp.right add to queue
"""
# instantiating queue and adding initial node
level_queue = Queue()
level_queue.enqueue(node)
# while the queue has stuff in it
while level_queue.size > 0:
# removing current node and save it as current node
current_node = level_queue.dequeue()
# printing each current node
print(current_node.value)
# if there is a node to the right, also add that to queue
if current_node.right:
level_queue.enqueue(current_node.right)
# if there is a node to the right, also add that to queue
if current_node.left:
level_queue.enqueue(current_node.left)
def bft_print(self, node):
q = Queue()
q.enqueue(starting_node)
while q.len() > 0:
current = q.dequeue()
print(current.value)
if current.left:
q.enqueue(current.left)
if current.right:
q.enqueue(current.right)
def bft_print(self, node):
queue = Queue()
queue.enqueue(node)
while queue.len():
item = queue.dequeue()
print(item.value)
if item.left:
queue.enqueue(item.left)
if item.right:
queue.enqueue(item.right)
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.cache = Queue()
self.dictionary = {}
self.length = 0
"""
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):
if key in self.dictionary:
node = self.dictionary[key]
print(1, node)
self.cache.storage.move_to_front(node)
# print('aaa',node.value[key])
return node.value[key]
else:
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):
if key in self.dictionary:
node = self.dictionary[key]
node.value = {key: value}
self.cache.storage.move_to_front(node)
else:
self.cache.enqueue({ key: value})
self.length += 1
if self.length > self.limit:
removed_item = self.cache.dequeue()
for dictionary_key in removed_item:
del self.dictionary[dictionary_key]
self.dictionary[key] = self.cache.storage.head
def bft_print(self, node):
queue = Queue()
queue.enqueue(node)
while queue.len():
current_node = queue.dequeue() # pop left
print(current_node.value) # d
if current_node.left:
queue.enqueue(current_node.left) # l
if current_node.right:
queue.enqueue(current_node.right) # r
"""
def bft_print(self, node):
q = Queue()
q.enqueue(node)
while q.len() > 0:
dq = q.dequeue()
print(dq.value)
if dq.left is not None:
q.enqueue(dq.left)
if dq.right is not None:
q.enqueue(dq.right)
def bft_print(self, node):
q = Queue()
q.enqueue(node)
while q.size > 0:
head = q.storage.head.value
print(head.value)
if head.left:
q.enqueue(head.left)
if head.right:
q.enqueue(head.right)
q.dequeue()
def bft_print(self, node):
queue_storage = Queue()
queue_storage.enqueue(node)
while queue_storage.len() > 0:
curr_node = queue_storage.dequeue()
print(curr_node.value)
if curr_node.left:
queue_storage.enqueue(curr_node.left)
if curr_node.right:
queue_storage.enqueue(curr_node.right)
def bft_print(self, node):
self.queue = Queue()
self.queue.enqueue(node)
while self.queue.len() > 0:
node = self.queue.dequeue()
if node.left:
self.queue.enqueue(node.left)
if node.right:
self.queue.enqueue(node.right)
print(node.value)
