Ejemplo n.º 1
0
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
Ejemplo n.º 2
0
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())
Ejemplo n.º 3
0
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()
Ejemplo n.º 4
0
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()
Ejemplo n.º 5
0
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
Ejemplo n.º 6
0
    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()
Ejemplo n.º 9
0
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()))
Ejemplo n.º 11
0
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]
Ejemplo n.º 12
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
Ejemplo n.º 13
0
 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)
Ejemplo n.º 14
0
 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)
Ejemplo n.º 15
0
 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)
Ejemplo n.º 16
0
    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)
Ejemplo n.º 17
0
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
Ejemplo n.º 18
0
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)
Ejemplo n.º 19
0
 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
Ejemplo n.º 20
0
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
Ejemplo n.º 21
0
    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)
Ejemplo n.º 22
0
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)
Ejemplo n.º 23
0
    def printTreeInLevelOrder(self, root):
        """
        1
        2 3
        4 5 6 7
        """

        q = Queue()
        q.enqueue(root)
        node = q.dequeue()
        print node.data
Ejemplo n.º 24
0
 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)
Ejemplo n.º 25
0
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"
Ejemplo n.º 26
0
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
Ejemplo n.º 28
0
    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()
Ejemplo n.º 29
0
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()
Ejemplo n.º 30
0
 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)
Ejemplo n.º 31
0
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)
Ejemplo n.º 33
0
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
Ejemplo n.º 34
0
    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)
Ejemplo n.º 35
0
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()
Ejemplo n.º 36
0
    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)
Ejemplo n.º 37
0
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())
Ejemplo n.º 38
0
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)
Ejemplo n.º 40
0
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()
Ejemplo n.º 41
0
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)
Ejemplo n.º 42
0
 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")        
Ejemplo n.º 43
0
 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)
Ejemplo n.º 44
0
 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)
Ejemplo n.º 45
0
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
Ejemplo n.º 47
0
 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
Ejemplo n.º 48
0
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)
Ejemplo n.º 49
0
    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)
Ejemplo n.º 51
0
 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
Ejemplo n.º 52
0
    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')
Ejemplo n.º 54
0
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
Ejemplo n.º 55
0
    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()) )
Ejemplo n.º 56
0
 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
Ejemplo n.º 57
0
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()))