class QStack(object): """ Use Queue to implement Stack q1 always contain items q2 uses for pop item iterate all items store from q1 to q2 keep the last q1 item, then pop it """ def __init__(self): self._q1 = Queue() self._q2 = Queue() self._size = 0 def is_empty(self): return self._size == 0 def push(self, item): print('Push item %d' %item) self._q1.enqueue(item) self._size += 1 def pop(self): if self.is_empty(): print('Stack is empty.') return None idx = self._size while idx > 1: self._q2.enqueue(self._q1.dequeue()) idx -= 1 else: item = self._q1.dequeue() self._size -= 1 self._q1, self._q2 = self._q2, self._q1 print('Pop item %d' %item) return item
def testQueue(): q = Queue() q.enqueue('hello') q.enqueue('dog') q.enqueue(3) print ("Deq: ", q.dequeue()) while not q.is_empty(): print (q.dequeue())
def hot_potato(name_list, num): sim_queue = Queue() for name in name_list: sim_queue.enqueue(name) while sim_queue.size() > 1: for i in range(num): sim_queue.enqueue(sim_queue.dequeue()) #sim_queue.dequeue() return sim_queue.dequeue()
def hotPotato(players, num): simQ = Queue() for p in players: simQ.enqueue(p) while simQ.size() > 1: for i in range(num): simQ.enqueue(simQ.dequeue()) simQ.dequeue() return simQ.dequeue()
class animatedLinkedList: def __init__(self): window = Tk() window.title("Linked List") self.lst = Queue() self.canvas = Canvas(window, width = 400, height = 200) self.canvas.pack() frame = Frame(window) frame.pack() Label(frame, text = "Element").pack(side = LEFT) self.v1 = StringVar() self.v1.set("") Entry(frame, textvariable = self.v1).pack(side = LEFT) self.lstx = 10 self.lsty = 80 self.bx = 10 self.by = 100 Button(frame, text = "Insert (enqueue)", command = self.insert).pack(side = LEFT) Button(frame, text = "Delete (dequeue)", command = self.delete).pack(side = LEFT) window.mainloop() def insert(self): if self.v1.get() == "": tkinter.messagebox.showerror("Error", "No input in element") else: self.lst.enqueue(int(self.v1.get())) self.update() def delete(self): self.lst.dequeue() self.update() def update(self): self.canvas.delete(ALL) x = self.lst.getSize() self.lstx = 10 self.lsty = 80 self.n = self.lst.__str__() self.n = self.n.split(", ") if len(self.n) > 1: a = self.n[0] self.n[0] = a.replace("[", "") b = self.n[len(self.n) - 1] self.n[len(self.n) - 1] = b.replace("]", "") elif len(self.n) == 1: a = self.n[0] a = a.replace("[", "") a = a.replace("]", "") self.n[0] = a print(self.n) for i in range(x): self.canvas.create_rectangle(self.lstx, self.lsty, self.lstx + 30, self.lsty + 20) self.canvas.create_text(self.lstx + 15, self.lsty + 10, text = self.n[i]) self.lstx += 30
def test_empty_queue(self): queue = Queue() self.assertEqual(queue.head, None) self.assertEqual(queue.tail, None) self.assertTrue(queue.is_empty()) with self.assertRaises(Queue.Empty): queue.peek() with self.assertRaises(Queue.Empty): queue.dequeue()
def hot_potato(l, num): q = Queue() for i in l: q.enqueue(i) while q.size() > 1: for j in range(num): q.enqueue(q.dequeue()) q.dequeue() return q.dequeue()
def josephus(namelist, num): simqueue = Queue() for name in namelist: simqueue.enqueue(name) while simqueue.size() > 1: for i in xrange(num): simqueue.enqueue(simqueue.dequeue()) simqueue.dequeue() return simqueue.dequeue()
def hotPotato(players): if players is None or len(players) <= 1: return players simQ = Queue() plsize = len(players) for p in players: simQ.enqueue(p) while simQ.size() > 1: r = random.randint(plsize, plsize*2) for i in range(r): simQ.enqueue(simQ.dequeue()) simQ.dequeue() return simQ.dequeue()
def simulation(simulationTime, pagesPerMinute): # create a printer with a specific page rate labprinter = Printer(pagesPerMinute) printQueue = Queue() # waiting times list used for extracting meaningful content from the simulation waitingtimes = [] # run simulationTime seconds for currentSecond in range(simulationTime): if newPrintTask(): # create a new task if newPrintTask has randomly created a task task = printJob(currentSecond) # enqueue task to the print Queue printQueue.enqueue(task) # if printer is free and printQueue has jobs to process if (not labprinter.busy()) and (not printQueue.is_empty()): # process printJob nexttask = printQueue.dequeue() # keep track of how long printJob had to wait in the queue waitingtimes.append( nexttask.waitTime(currentSecond)) # start printing next task labprinter.startNextTask(nexttask) labprinter.tick() averageWait=sum(waitingtimes)/len(waitingtimes) print("Average Wait %6.2f secs %3d tasks remaining."%(averageWait,printQueue.size()))
def test_dequeue(): """Test dequeue method.""" from Queue import Queue q = Queue() q.enqueue(data[0]) q.enqueue(data[1]) assert q.dequeue() == data[0]
def BFS(G,s): """ Breadth First Search a Graph """ color = {} distance = {} parent = {} Q = Queue([]) for vertex in G.getVertexes(): color[vertex] = 0 distance[vertex] = float('inf') parent[vertex] = None color[s] = 1 distance[s] = 0 parent[s] = None Q.enqueue(s) while len(Q) != 0: u = Q.dequeue() for i in G.getAdjacencyVertexes(u): if color[i] == 0: color[i] = 1 distance[i] = distance[u]+1 parent[i] = u Q.enqueue(i) color[u] = 2
def crawl(self): f = FileHandling("crawl_all_links.txt") q = Queue() count = 0 depth = 0 q.enqueue(self.mainurl) while not q.isEmpty(): cURL = q.dequeue() time.sleep(1) source = requests.get(cURL) soup = BeautifulSoup(source.text,'html.parser') #print(cURL) count += 1 for link in soup.findAll("a"): #print(link.get("href")) ln = link.get("href") if ln is not None: full_url=self.filter(link.get("href")) if full_url != "": print(full_url) f.log_msg(full_url) q.enqueue(full_url) count+=1 depth+=1 if depth >= self.depth or count >= self.mcount: break print("Number of URL crawled:",count,"Depth of crawled data:",depth)
def crawl_word(self,word): f = FileHandling("crawl_"+word+".txt") q = Queue() count = 0 depth = 0 q.enqueue(self.mainurl) while not q.isEmpty(): cURL = q.dequeue() #time.sleep(1) source = requests.get(cURL) soup = BeautifulSoup(source.text,'html.parser') if soup.find(text=re.compile(word, re.I)) is not None: print(cURL) f.log_msg(cURL) count+=1 for link in soup.findAll("a"): #print(link.get("href")) ln = link.get("href") if ln is not None: #print(ln) full_url=self.filter(link.get("href")) if full_url != "": q.enqueue(full_url) if count > self.mcount: break print("Number of URL crawled:",count,"Depth of crawled data:",depth)
def crawl_images(self,number): #f = FileHandling("crawl_all_links.txt") q = Queue() count = 0 q.enqueue(self.mainurl) while not q.isEmpty(): cURL = q.dequeue() time.sleep(1) source = requests.get(cURL) soup = BeautifulSoup(source.text,'html.parser') #print(cURL) for im in soup.findAll("img"): im_ln = im.get("src") if im_ln is not None: print(self.imgfilter(im_ln)) IMAGE = im_ln.rsplit('/',1)[1] try: urllib.request.urlretrieve(self.imgfilter(im_ln), self.imageout+IMAGE) count+=1 except: print("Invalid url...Ignoring") for link in soup.findAll("a"): #print(link.get("href")) ln = link.get("href") if ln is not None: #print(ln) full_url=self.filter(link.get("href")) if full_url != "": q.enqueue(full_url) if count > number: break print("Number of Images crawled:",count)
def testQueue(self): queue = Queue() with self.assertRaises(Exception): queue.dequeue() queue.enqueue(12) queue.enqueue(10) queue.enqueue(17) queue.enqueue(7) queue.enqueue(21) self.assertEqual(queue.head.data, 12) self.assertEqual(queue.tail.data, 21) queue.dequeue() queue.dequeue() self.assertEqual(queue.head.data, 17) self.assertEqual(queue.dequeue(), 17)
def radixSort(nums): """ we are taking the input as list of numbers (in string format) reason being - it will ease in indexing and getting the individual digits with the help of string utilities. Return - we return a list of numbers which are sorted in increasing order""" if nums is None or len(nums) < 1: return nums mainQ = Queue() binQs = [] # Add all the numbers in the main Queue for n in nums: mainQ.enqueue(n) # create an array of Queues and initialize them - bin 0 to 9 for i in range(10): binQs.append(Queue()) # get the max length of digits in any input number - this will decide the # outer iteration we need to do in our radix sort implementation maxLen = len(nums[0]) for i in range(1, len(nums)): if len(nums[i]) > maxLen: maxLen = len(nums[i]) # we need to iterate maxLen times ie length of the biggest number (in # digits) for i in range(1, maxLen + 1): visited = [] # below iteration includes only numbers of digit length i while not mainQ.is_empty(): val = mainQ.dequeue() if i > len(val): visited.append(val) continue r = val[-i] #get the ith index from last r = int(r) binQs[r].enqueue(val) for v in visited: mainQ.enqueue(v) for i in range(10): while not binQs[i].is_empty(): mainQ.enqueue(binQs[i].dequeue()) result = [] while not mainQ.is_empty(): result.append(mainQ.dequeue()) return result
def levelOrderTraversal(root): qu = Queue() qu.enqueue(root) while not qu.isEmpty(): node = qu.dequeue() print(node.data,end=" ") if node.left: qu.enqueue(node.left) if node.right: qu.enqueue(node.right)
def test_dequeue(self): mock_item1 = MagicMock() mock_item2 = MagicMock() queue = Queue() queue.enqueue(mock_item1) queue.enqueue(mock_item2) assert queue.is_empty() == False assert queue.dequeue() == mock_item1 assert queue.dequeue() == mock_item2 assert queue.is_empty() == True
def radixSort(nums): """ we are taking the input as list of numbers (in string format) reason being - it will ease in indexing and getting the individual digits with the help of string utilities. Return - we return a list of numbers which are sorted in increasing order""" if nums is None or len(nums) < 1: return nums mainQ = Queue() binQs = [] # Add all the numbers in the main Queue for n in nums: mainQ.enqueue(n) # create an array of Queues and initialize them - bin 0 to 9 for i in range(10): binQs.append(Queue()) # get the max length of digits in any input number - this will decide the # outer iteration we need to do in our radix sort implementation maxLen = len(nums[0]) for i in range(1, len(nums)): if len(nums[i]) > maxLen: maxLen = len(nums[i]) # we need to iterate maxLen times ie length of the biggest number (in # digits) for i in range(1, maxLen+1): visited = [] # below iteration includes only numbers of digit length i while not mainQ.is_empty(): val = mainQ.dequeue() if i > len(val): visited.append(val) continue r = val[-i] #get the ith index from last r = int(r) binQs[r].enqueue(val) for v in visited: mainQ.enqueue(v) for i in range(10): while not binQs[i].is_empty(): mainQ.enqueue(binQs[i].dequeue()) result = [] while not mainQ.is_empty(): result.append(mainQ.dequeue()) return result
def testCheckFirstAndDequeueReturnsExpectedValues(self): queue = Queue() for k in range(0, queue.MAX): queue.enqeue(k) tailleAttendue = queue.size() #tests pour le premier element self.assertEqual(str(queue.check_first()), str(0)) self.assertEqual(str(queue.check_last()), str(99)) self.assertTrue(queue.isFull()) self.assertEqual(queue.size(), tailleAttendue) self.assertEqual(str(queue.dequeue()), str(0)) self.assertFalse(queue.isFull()) tailleAttendue = tailleAttendue - 1 self.assertEqual(queue.size(), tailleAttendue) #tests pour les elements intermediaires for k in range(1, queue.MAX - 1): self.assertEqual(str(queue.check_last()), str(99)) self.assertEqual(str(queue.check_first()), str(k)) self.assertEqual(str(queue.dequeue()), str(k)) self.assertFalse(queue.isFull()) tailleAttendue = tailleAttendue - 1 self.assertEqual(queue.size(), tailleAttendue) #tests pour le dernier element self.assertEqual(queue.size(), 1) self.assertTrue(queue.hasOne) self.assertRaises(ValueError, queue.check_last) self.assertEqual(str(queue.check_first()), str(99)) self.assertEqual(str(queue.dequeue()), str(99)) self.assertEqual(queue.size(), 0) self.assertTrue(queue.hasOne) self.assertRaises(ValueError, queue.check_first) self.assertRaises(ValueError, queue.check_last)
def breadth_first(a): result_list = [] queue = Queue() queue.enqueue(a) while not queue.is_empty(): treenode = queue.dequeue() if treenode is not None: queue.enqueue(treenode.get_left()) queue.enqueue(treenode.get_right()) result_list.append(treenode.get_data()) return (result_list)
def printTreeInLevelOrder(self, root): """ 1 2 3 4 5 6 7 """ q = Queue() q.enqueue(root) node = q.dequeue() print node.data
def bfs(self, node): visited = [node] queue = Queue() queue.enqueue(node) while queue: node_ = queue.dequeue() for neighbor in self.neighbors(node_): if neighbor not in visited: queue.enqueue(neighbor) visited.append(neighbor) print(visited)
def test_queue(): # Setup q = Queue() q.enqueue(1) q.enqueue(2) q.enqueue(3) # Test size assert q.size() == 3, 'Fail' # Test dequeue assert q.dequeue() == 1, 'Fail' # Test enqueue q.enqueue(4) assert q.dequeue() == 2, 'Fail' assert q.dequeue() == 3, 'Fail' assert q.dequeue() == 4, 'Fail' q.enqueue(5) assert (q.size() == 1), "Fail"
def reachable(G, v): rset = {} rset[v] = 0 # w is marked (in the keys of rset), with distance myq = Queue([v]) while (not myq.isempty()): w = myq.dequeue() for ngh in G[w]: if not (ngh in rset.keys()): rset[ngh] = rset[w] + 1 myq.enqueue(ngh) return (rset)
def levelorder(self): result = [] queue = Queue() queue.enqueue(self.get_root()) while not queue.is_empty(): current = queue.dequeue() result.append(current) if current.get_left() is not None: queue.enqueue(current.get_left()) if current.get_right() is not None: queue.enqueue(current.get_right()) return result
def BFS(self): s = Queue() s.enqueue(self.root) while not s.isEmpty(): node = s.dequeue() if node is None: continue print(node.value, end=' ') s.enqueue(node.right) s.enqueue(node.left) print()
def build_queue(data_list): q = Queue() for data in data_list: q.enqueue(data) q.display() print(q.length()) for i in range(1): # print(q.peek()) q.enqueue(q.dequeue()) q.display()
def levelOrder(self): """Breadth-First Traversal""" from Queue import Queue q = Queue() q.enqueue(self.root) while not q.isEmpty(): node = q.dequeue() print node.value if node.left: q.enqueue(node.left) if node.right: q.enqueue(node.right)
def isConnectedBFSHelper(graph, node1Key, node2Key): node1 = graph.getNodeByKey(node1Key) q = Queue() q.enqueue(node1) while not q.isEmpty(): node = q.dequeue() node.isChecked = True for eachNode in node.adjacents: if eachNode.key == node2Key: return True if not eachNode.isChecked: q.enqueue(eachNode)
def bfs_search(self, root): queue = Queue() root.visited = True queue.enqueue(root) while not queue.is_empty(): r = queue.dequeue() print(r) for node in r.links: if node.visited is False: node.visited = True queue.enqueue(node)
def levelOrderTraversal(root): q = Queue(13) q.enqueue(root) traversal = [] while not q.isEmpty(): node = q.dequeue() traversal.append(node.data) node = node.getFirstChild() while node is not None: q.enqueue(node) node = node.getNextSibling() return traversal
def _bfs(self, graph, s): q = Queue() self.makred[s] = True q.enqueue(s) while not q.isEmpty(): v = q.dequeue() for w in graph.adj(v): if self.makred[w] is False: self.edgeTo[w] = v self.makred[w] = True q.enqueue(w)
class MyStack: def __init__(self): self.queue1 = Queue() self.queue2 = Queue() def push(self, value): self.queue1.enqueue(value) def pop(self): while not self.queue1.empty(): value = self.queue1.dequeue() if not self.queue1.empty(): self.queue2.enqueue(value) while not self.queue2.empty(): self.queue1.enqueue(self.queue2.dequeue()) return value def empty(self): return self.queue1.empty()
def display_level_order(self): if self.root == None: return queue = Queue() queue.enqueue(self.root) while not queue.isEmpty(): current = queue.front_value() queue.dequeue() print(current.data) if current.left != None: queue.enqueue(current.left) if current.right != None: queue.enqueue(current.right)
def test_queue(test_cases_size=50): print "######################## QUEUE TEST CASES ############################" my_queue = Queue() for i in range(0, test_cases_size): my_queue.enqueue("elm" + str(i)) for i in range(0, test_cases_size): print "queue elements" my_queue.print_queue() print "first come first serve: " + str(my_queue.dequeue())
def bfs(g, s): visited = [] st = Queue() st.enqueue(s) #Assuming s is in g while not st.isEmpty(): cn = st.dequeue() if cn not in visited: visited.append(cn) for c in g.children(cn): if c not in visited: st.enqueue(c) return visited
def _bfs(self,graph,s): q = Queue() self.makred[s] = True q.enqueue(s) while not q.isEmpty(): v = q.dequeue() for w in graph.adj(v): if self.makred[w] is False: self.edgeTo[w] = v self.makred[w] = True q.enqueue(w)
class AnimalShelter: def __init__(self): self.dogQueue = Queue() self.catQueue = Queue() def enqueue(self, newAnimal): if isinstance(newAnimal, Dog): self.dogQueue.enqueue(newAnimal) elif isinstance(newAnimal, Cat): self.catQueue.enqueue(newAnimal) else: assert(False) def dequeueAny(self): firstDog = self.dogQueue.peek() firstCat = self.catQueue.peek() if firstDog == None: return self.catQueue.dequeue() if firstCat == None: return self.dogQueue.dequeue() if firstDog.order < firstCat.order: return self.dogQueue.dequeue() else: return self.catQueue.dequeue() def dequeueDog(self): return self.dogQueue.dequeue() def dequeueCat(self): return self.catQueue.dequeue()
class CallCenter: def __init__(self): self.employees = { 'respondents': [], 'managers': [], 'directors': [] } self.incoming_calls = Queue() def add_calls_to_waiting_list(self, call): self.incoming_calls.enqueue(call) def search_for_availability(self, employee_type): e = 0 while not self.employees[employee_type][e].is_available and \ e < len(self.employees[employee_type]): e += 1 return e def dispatch_call(self): """ Assigns respondents to calls in the queue type: None return type: Respondent """ while not self.incoming_calls.isEmpty(): call = self.incoming_calls.dequeue() # find a respondent who is available avbl_respondent = self.search_for_availability(self, 'respondents') # case: no respondents are available # dispatch to first available manager if avbl_respondent == len(self.employees['respondents']): avbl_manager == self.search_for_availability(self, 'managers') # case: no managers are available # dispatch to first available director if avbl_manager == len(self.employees['directors']): avbl_director = self.search_for_availability('directors') # case: we found an available manager # assign their availability to False else: self.employees['managers'][avbl_manager].is_available = False self.employees['managers'][avbl_manager].calls.append(call) # case: we found an available respondent # assign their availability to False else: self.employees['respondents'][avbl_respondent].is_available = False self.employees['respondents'][avbl_respondent].calls.append(call)
def BFS(self,start): start.setDistance(0) vertQueue= Queue() vertQueue.enqueue(start) while(vertQueue.size()>0): currentVert=vertQueue.dequeue() for nbr in currentVert.getConnections(): if(nbr.getColor()=="white"): nbr.setColor("gray") nbr.setDistance(currentVert.getDistance()+1) nbr.setPred(currentVert) vertQueue.enqueue(nbr) currentVert.setColor("black")
def bfsFromVertex(graph,val,visited): visited.add(val) print(val) q = Queue() q.enqueue(val) while(not q.isEmpty()): v = q.dequeue() if(v in graph.__dict.keys()): for adjV in graph.__dict[v]: if(adjV not in visited): print(adjV) visited.add(adjV) q.enqueue(adjV)
def bfs(self, graph, s): ##bfs中使用的队列 queue = Queue() self.marked[s] = True queue.enqueue(s) while not queue.is_empty(): ##从queue中删除一个节点 v = queue.dequeue() for w in graph.getAdj(v): if not self.marked[w]: self.edgeTo[w] = v self.marked[w] = True queue.enqueue(w)
def bfs( start, visited ): # visited is a list that contains all the elements that have already been visited - this increases the space complexity since a better way can be to give the Node class a state value that determines if the node is visited or not visited.append(start) queue = Queue() queue.enqueue(start) while len(queue) != 0: current = queue.dequeue() print(current.data, end=" ") for neighbor in current.neighbors: if neighbor not in visited: queue.enqueue(neighbor) visited.append(neighbor)
def bfs(self, element): result = [] queue = Queue() queue.enqueue(self.get_root()) while not queue.is_empty(): current = queue.dequeue() if current.get_data() == element: return element if current.get_left() is not None: queue.enqueue(current.get_left()) if current.get_right() is not None: queue.enqueue(current.get_right()) return None
def BFS(self, vertex): print("BFS traversal of this graph starting from %d is:" % vertex) visitedStatus = [False for i in range(self.size)] traversalQueue = Queue(self.size) traversalQueue.enqueue(vertex) visitedStatus[vertex] = True while traversalQueue.isEmpty() is False: element = traversalQueue.dequeue() print(element) for v, w in self.adjacencyList[element]: if visitedStatus[v] is False: traversalQueue.enqueue(v) visitedStatus[v] = True
class TestStringMethods(unittest.TestCase): def setUp(self): self.q = Queue() def test_str(self): self.assertEqual(str(self.q), '') self.q.enque(4) self.assertEqual(str(self.q), '4') def test_enque(self): self.q.enque(4) self.assertEqual(self.q.front.data, 4) self.assertEqual(self.q.back.data, 4) self.q.enque(5) self.assertEqual(self.q.front.data, 4) self.assertEqual(self.q.back.data, 5) def test_deque(self): self.assertEqual(self.q.dequeue(), None) self.q.enque(4) self.assertEqual(self.q.dequeue(), 4) self.assertEqual(self.q.dequeue(), None) self.q.enque(5) self.q.enque(6) self.assertEqual(self.q.dequeue(), 5) self.q.enque(4) self.assertEqual(self.q.dequeue(), 6) self.assertEqual(self.q.dequeue(), 4) def test_len(self): self.q.enque(4) self.assertEqual(len(self.q), 1) self.q.enque('5') self.assertEqual(len(self.q), 2) self.q.enque(None) self.assertEqual(len(self.q), 3)
def bfs(self): """ Returns the path from the start position to the goal position using breath first search (BFS). Returns <None> if no solution is found. """ # Initialize the queue queue = Queue() # Add the start point to the queue queue.enqueue(self.start) previous = {self.start: None} self.added = 1 # Loop until the queue is empty self.visited = 0 while (not queue.is_empty()): # Get the last item from the queue current = queue.dequeue() self.visited += 1 # Stop if it is the goal and return the path if (current == self.goal): path = self.get_path(previous) return path # Define the order in the directions idx = self.order_dir() # Add to the queue the neighbours of the current position for direction in idx: # Offset values row_offset, col_offset = self.offset[direction] # Neighbour position row_neigh = current[0] + row_offset col_neigh = current[1] + col_offset neighbour = (row_neigh, col_neigh) # If neighbour position is valid and not in the dictionary if (self.layout[row_neigh][col_neigh] != '#' and self.layout[row_neigh][col_neigh] != '*' and neighbour not in previous): # Add it to the queue queue.enqueue(neighbour) previous[neighbour] = current self.added += 1 return None
def q(): print("Q()") from Queue import Queue s = Queue() #print(s.is_empty()) s.enqueue("one") s.enqueue("two") s.enqueue("three") print(s.items) #print(s.peek()) #print(s.size()) #print(s.is_empty()) print(s.dequeue()) # "one" print(s.items) s.enqueue("four") print(s.items) print(s.dequeue()) # "two" print(s.items) print(s.dequeue()) # "three" print(s.items) s.enqueue("five") print(s.items) print(s.dequeue()) # "four" print(s.items)
def BFS(self): # n = QNode(self.root) Q = Queue(self.root) while(Q.size > 0): n = Q.head if n.data is not None: # we have a leaf node skip Q.enqueue(QNode(n.data.left)) Q.enqueue(QNode(n.data.right)) old = Q.dequeue() if old.data is None: print "," else: print old.data.value return Q
def breadth_first(self): current_node = self.root q = Queue() data_output = [] while current_node != None: ##data_output.append([current_node.data,current_node.bin_id]) data_output.append(current_node.data) if current_node.left != None: q.enqueue(current_node.left) if current_node.right != None: q.enqueue(current_node.right) current_node = q.dequeue() return data_output
def bfs(g,start): start.setDistance(0) start.setPred(None) vertQueue = Queue() vertQueue.enqueue(start) while (vertQueue.start() > 0): currentVert = vertQueue.dequeue() for nbr in currentVert.getconnections(): if (nbr.getcolor() == 'white'): nbr.setColor('gray') nbr.setDistance(currentVert.getDistance() + 1) nbr.setPred(currentVert) vertQueue.enqueue(nbr) currentVert.setColor('black')
def bfs1(graph,root,target): q = Queue() visited = [] q.enqueue(root) while not q.isEmpty(): removeNode = q.dequeue() if removeNode == target: return True elif v not in visited: for edge in graph[v]: if v not in visited: q.enqueue(edge) visited.append(v) return False
def simulation(num_seconds, pages_per_minute): lab_printer = Printer(pages_per_minute) print_queue = Queue() waiting_times = [] for current_second in range(num_seconds): if new_print_task(): task = Task(current_second) print_queue.enqueue(task) if (not lab_printer.busy()) and (not print_queue.is_empty()): next_task = print_queue.dequeue() waiting_times.append(next_task.wait_time(current_second)) lab_printer.startNext(next_task) lab_printer.tick() average_wait = sum(waiting_times) / len(waiting_times) print("Average Wait %6.2f secs %3d tasks remaining." %(average_wait, print_queue.size()) )
def dfs (self): q = Queue() arr = [] q.enqueue (self) while ( not q.isEmpty()): item = q.dequeue() arr.append (item.value) left = item.left right = item.right if (left is not None): q.enqueue (left) if (right is not None): q.enqueue (right) return arr
def simulation(seconds, ppm): printQueue = Queue() waitingtimes = [] printer = Printer(ppm) for currentSecond in range(seconds): if newPrintTask(): printQueue.enqueue(Task("Task"+str(currentSecond), currentSecond)) if (not printer.busy()) and (not printQueue.isEmpty()): nexttask = printQueue.dequeue() waitingtimes.append(nexttask.getWaitTime(currentSecond)) printer.nextTask(nexttask) printer.tick() lenWaitTime = len(waitingtimes) averageWait=sum(waitingtimes)/lenWaitTime print("Average Wait %6.2f secs %3d tasks remaining."%(averageWait,printQueue.size()))