Python Queue.isEmpty方法代码示例

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import isEmpty [as 别名]
def main():
	q = Queue()
	q.isEmpty()
	q.enqueue(9)
	q.enqueue(2)
	q.enqueue(3)
	q.isEmpty()
	q.size()
	q.peek()
	q.print_list()

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import isEmpty [as 别名]
def wordLadderII(start, end, d):
    q = Queue()
    q.enqueue(start)
    q.enqueue('endLevel')
    h = {}
    res = 1
    visitedWord = []
    while not q.isEmpty():
        tmpWord = q.dequeue()
        if tmpWord == 'endLevel':
            res += 1
            q.enqueue('endLevel')
        else:
            for i in range(len(tmpWord)):
                for c in string.lowercase[:26]:
                    newWord = tmpWord[:i] + c + tmpWord[i+1:]
                    if newWord == end:
                        curr = [newWord]
                        prev = h.get(newWord,[tmpWord])
                        prev.extend(curr)
                        return prev
                    elif newWord in d:
                        prev = h.get(newWord,[tmpWord])
                        prevCopy = prev[:]
                        prevCopy.append(tmpWord)
                        h[newWord] = prevCopy
                        if newWord not in q and newWord not in visitedWord:
                            q.enqueue(newWord)
                            
    return 0

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import isEmpty [as 别名]
def simulation(seconds, ppm):

    printer = Printer(ppm)
    q = Queue()
    waittimes = []

    for currentSecond in range(seconds):

        if newPrintTask():
            task = Task(currentSecond)
            q.enqueue(task)

        if (not printer.isBusy()) and (not q.isEmpty()):
            nextTask = q.dequeue()
            waittimes.append(nextTask.getTimeWaited(currentSecond))

            printer.startNextTask(nextTask)


        printer.countdown()

    averageWait = sum(waittimes)/len(waittimes)

    print "Average wait of %6.2f seconds; %3d tasks remaining." \
            % (averageWait, q.size())
    return

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import isEmpty [as 别名]
class QueueTest(unittest.TestCase):
   def setUp(self):
      self.myqueue = Queue()

   def tearDown(self):
      del(self.myqueue)

   def test_create_empty_queue(self):
      self.assertEqual(self.myqueue.isEmpty(), True)

   def test_enqueue_element(self):
      self.myqueue.enqueue(1)
      self.assertEqual(self.myqueue.items[0], 1)

   def test_dequeue_element(self):
      self.myqueue.items.append(1)
      self.assertEqual(self.myqueue.dequeue(), 1)

   def test_ordering_enqueue_dequeue(self):
      self.myqueue.enqueue(1)
      self.myqueue.enqueue(2)
      self.assertEqual(self.myqueue.dequeue(), 1)
      self.assertEqual(self.myqueue.dequeue(), 2)

   def test_queue_size(self):
      self.myqueue.enqueue(1)
      self.myqueue.enqueue(2)
      self.myqueue.enqueue(3)
      self.assertEqual(self.myqueue.size(), 3)

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import isEmpty [as 别名]
def bfs(G, start):
    state = {}
    parentList = {}
    order = []
    # print "bfs started -- start :", start.name
    for vert in G:
        state[vert.name] = "undiscovered"
        parentList[vert.name] = None
    state[start.name] = "discovered"
    Q = Queue()
    Q.enqueue(start)
    while Q.isEmpty() == False:
        u = Q.dequeue()
        order.append(u.name)
        # print "Dequeued vertex", u.name
        # print "vertex adjs "
        # for v in u.connectedTo:
        #    print v.name,
        # print ""
        for v in u.connectedTo:
            if state[v.name] == "undiscovered":
                state[v.name] == "discovered"
                parentList[v.name] = u.name
                vert_v = G.getVertex(v.name)
                if Q.contains(vert_v) == False:
                    Q.enqueue(vert_v)
                    # print "Enqueued new", v.name
        state[u.name] = "processed"
    return order

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import isEmpty [as 别名]
def calcMinCoinNumForValue2(coinValueList, totalValue):
    knownCoinNumForValue = {}
    knownCoinChoice = {}
    knownCoinChoice[0] = ''
    q = Queue()
    q.enqueue((0,0))
    q.enqueue('endLevel')   # flag indicating end of level
    level = 1
    cnt = 0
    while(not q.isEmpty()):
        e = q.dequeue()
        if e== 'endLevel':
            level+=1
            q.enqueue('endLevel')
        else:
            currVal,valAdded = e
            for vi in coinValueList:
                if vi>=valAdded:
                    nextVal = currVal+vi
                    if nextVal==totalValue:
                        print str(vi)+' '+knownCoinChoice.get(currVal,'') # return empty string '' if knownCoinChoice[currVal] is undefined
                        print cnt
                        return level
                    elif nextVal>totalValue:
                        break
                    else:
                        cnt += 1
                        q.enqueue((nextVal,vi))
                        knownCoinNumForValue[nextVal]=level
                        if not knownCoinChoice.has_key(nextVal):
                            knownCoinChoice[nextVal] = str(vi)+' '+knownCoinChoice.get(currVal,'')

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import isEmpty [as 别名]
	def buscaAmplitude(self,origin,destination):
		position = origin
		checked = []
		queue = Queue()

		if (position == destination):
			return True
		checked.append(position)
		queue.enqueue(position)

		while(not queue.isEmpty()):
			position = queue.dequeue()
			if (position == destination):
				return True
			checked.append(position)

			neighbors = self.neighbors(position)
			while(len(neighbors) != 0):
				position = neighbors.pop(0)

				try:
					i = checked.index(position)
				except ValueError:
					i = -1

				if (i == -1):
					if (position == destination):
						return True
					checked.append(position)
					queue.enqueue(position)

		return False

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import isEmpty [as 别名]
 def buildNodeList(self):
     result = {}
     if self.root:
         q = Queue()
         visitedNode = []
         q.enqueue(self.root)
         q.enqueue('EndLevelFlag')
         level = 0
         while(not q.isEmpty()):
             tmp = q.dequeue()
             if tmp == 'EndLevelFlag':
                 # finish building the current level
                 level += 1
             else:
                 # add node to Linked List
                 visitedNode.append(tmp)
                 if level in result.keys():
                     result[level].append(tmp)
                 else:
                     aList = LinkedList()
                     aList.append(tmp.value)
                     result[level] = aList
                 if tmp.left: q.enqueue(tmp.left)
                 if tmp.right: q.enqueue(tmp.right)
                 # add dummy item to represent the end of level
                 q.enqueue('EndLevelFlag')
     return result

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import isEmpty [as 别名]
def josephus(N, M):
    q = Queue()
    for i in range(N):
        q.enqueue(i)
    result = []
    while not q.isEmpty():
        for i in range(M-1):
            q.enqueue(q.dequeue())
        result.append(q.dequeue())
    return result

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import isEmpty [as 别名]
def searchBFS(graph, start):
    visited = []
    queue = Queue()
    queue.enqueue(start)
    while not queue.isEmpty():
        current = queue.dequeue()
        if current not in visited:
            visited.append(current)
            for edges in graph[current]:
                queue.enqueue(edges)
    return visited

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import isEmpty [as 别名]
 def breadthFirstSearchTraverse(self, startVertex):  # use a queue to store the temporory vertex
     vertexQueue = Queue()
     if startVertex in self:
         vertexQueue.enqueue(startVertex)
     visitedVertex = []
     while not vertexQueue.isEmpty():
         currentVertex = vertexQueue.dequeue()
         visitedVertex.append(currentVertex)
         for neighborVertex in self.vertexList[currentVertex].getConnections():
             if neighborVertex.id not in visitedVertex:
                 vertexQueue.enqueue(neighborVertex.id)
     return visitedVertex

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import isEmpty [as 别名]
def solution(root):
    if root is None: return []
    q = Queue()
    q.enqueue(root)
    q.enqueue('EndLevel')
    res = []
    tmpRes = []
    while not q.isEmpty():
        tmp = q.dequeue()
        if tmp == 'EndLevel':
            res.append(tmpRes)
            tmpRes = []
            if not q.isEmpty():
                # otherwise infinite loop
                q.enqueue('EndLevel')
        else:
            tmpRes.append(tmp.val)
            if tmp.left: q.enqueue(tmp.left)
            if tmp.right: q.enqueue(tmp.right)
            
    return res[::-1]

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import isEmpty [as 别名]
def ladderLength(start, end, dict):
    q = Queue()
    h, step = {}, 1
    h[start] = 0
    q.enqueue(start)
    q.enqueue(0)
    while not q.isEmpty():
        curr = q.dequeue()
        if curr == 0:
            if q.isEmpty(): return h.get(end,0)
            else: 
                q.enqueue(0)
                step += 1
        else:
            for i in range(len(curr)):
                for c in 'abcdefghijklmnopqrstuvwxyz':
                    tmp = curr[:i] + c + curr[i+1:]
                    if tmp == end: return step
                    if tmp in dict:
                        if tmp not in h:
                            q.enqueue(tmp)
                            h[tmp] = step

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import isEmpty [as 别名]
def zigzagLevel(root):
    if root is None: return root
    q = Queue()
    q.enqueue(root)
    q.enqueue('end')
    level, currLevel, res = 0, [], []
    while not q.isEmpty():
        tmp = q.dequeue()
        if tmp == 'end':
            if level % 2: # flip odd level
                currLevel = [r for r in currLevel[::-1]]
            level += 1
            res.append(currLevel)
            currLevel = []
            if not q.isEmpty(): 
                q.enqueue('end')
        else:
            currLevel.append(tmp.value)
            if tmp.left: q.enqueue(tmp.left)
            if tmp.right: q.enqueue(tmp.right)
    for r in res:
        print r

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import isEmpty [as 别名]
 def levelOrder(self,a):
     q = Queue()
     r = a
     while r is not None:
         print(r.root.data)
         if r.root.left is not None:
             q.add(r.root.left)
         if r.root.right is not None:
             q.add(r.root.right)
         if q.isEmpty():
             print("empty")
             r = None
         else:
             r = q.delete()