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)