def test_linkedqueue_front(self): queue = LinkedQueue() for i in range(100): queue.enqueue(i + 1) for i in range(100): assert_equal(i + 1, queue.front()) queue.dequeue()
def stack_to_queue(my_stack): s = deepcopy(my_stack) q = LinkedQueue() while not s.isEmpty(): q.add(s.peek()) s.pop() return q
def rebalance(self): """ Re balances the tree. :return: rebalanced tree """ def tmp(qq, lst): tmp_lst = [lst] while True: new_tmp_lst = [] for l in tmp_lst: if not l: tmp_lst.remove(l) continue qq.add(l[len(l) // 2]) new_tmp_lst.append(l[:len(l) // 2]) new_tmp_lst.append(l[len(l) // 2 + 1:]) if not tmp_lst: break tmp_lst = new_tmp_lst res = [i for i in qq] return res res = [i for i in self.in_order()] q = LinkedQueue() tmp_list = (tmp(q, res)) self.clear() for each in tmp_list: self.add(each)
def __init__(self, numOfPlayers=2): self._numOfPlayers = numOfPlayers self._totalScore = 0 self._deck = Deck() self._queue = LinkedQueue() for player in range(self._numOfPlayers): self._queue.add(Player('Player ' + str(player + 1))) self._currentPlayer = self._queue.pop()
def __init__(self): """ """ self._totalCustomerWaitTime = 0 self._customersServed = 0 self._currentCustomer = None self._queue = LinkedQueue()
def test_linkedqueue_dequeue(self): queue = LinkedQueue() for i in range(100): queue.enqueue(i + 1) for i in range(100): assert_equal(i + 1, queue.dequeue()) assert_equal(99 - i, len(queue)) assert_equal(0, len(queue))
def __init__(self): """Maintains a queue of customers, number of customers served, total customer wait time, and a current customer being processed.""" self._totalCustomerWaitTime = 0 self._customersServed = 0 self._currentCustomer = None self._queue = LinkedQueue()
def __init__(self, number): """Maintains a cashier number, a queue of customers, number of customers served, total customer wait time, and a current customer being processed.""" self.number = number self.totalCustomerWaitTime = 0 self.customersServed = 0 self.currentCustomer = None self.queue = LinkedQueue()
def __init__(self, data1, data2, summary): """This method initializes.""" self.data1 = data1 self.data2 = data2 self.summary = summary self.queue = LinkedQueue() self.total_food = 0 self.total_transport = 0 self.extrainfo = "" self.see = ""
def test_push_to_queue(self): name = "Jose" phone = "123-456-7890" node = Node(name, phone) queue = LinkedQueue() queue.push(node) self.assertEqual(len(queue), 1)
def test_find_in_queue(self): name = "Jose" phone = "123-456-7890" node = Node(name, phone) queue = LinkedQueue() queue.push(node) self.assertEqual(queue.find(name), node)
def stack_to_queue(stack): """Return a queue that contains items from the stack.""" queue = LinkedQueue() item_list = [] for item in stack: item_list.insert(0, item) for item in item_list: queue.add(item) return queue
def levelorder(self): """Supports a levelorder traversal on a view of self.""" lyst = list() queue = LinkedQueue() if not self.isEmpty(): queue.add(self.root) while not queue.isEmpty(): node = queue.pop() lyst.append(node.data) if node.left != None: queue.add(node.left) if node.right != None: queue.add(node.right) return iter(lyst)
def bfs(g, start): start.setDistance(0) start.setPred(None) vertQueue = LinkedQueue() vertQueue.add(start) while not vertQueue.isEmpty(): currentVert = vertQueue.pop() for nbr in currentVert.getConnections(): if (nbr.getColor()) == 'white': nbr.setColor('gray') nbr.setDistance(currentVert.getDistance() + 1) nbr.setPred(currentVert) vertQueue.add(nbr) currentVert.setColor('black')
def test_pop_from_queue(self): name = "Jose" phone = "123-456-7890" node = Node(name, phone) queue = LinkedQueue() queue.push(node) self.assertEqual(len(queue), 1) popped = queue.pop() self.assertEqual(popped, node) self.assertEqual(len(queue), 0)
def breadthFirst(g, startLabel): """Returns a list of the vertex labels in the order in which the vertices were visited.""" result = list() g.clearVertexMarks() queue = LinkedQueue() queue.add(g.getVertex(startLabel)) while not queue.isEmpty(): vertex = queue.pop() if not vertex.isMarked(): vertex.setMark() result.append(vertex.getLabel()) for neighbor in g.neighboringVertices(vertex.getLabel()): if not neighbor.isMarked(): queue.add(neighbor) return result
def mazeSolver(maze, start, to_text=False, data_structure='stack'): """takes a maze and its starting point (as a tuple of row, column) and solves the maze. Maze walls must be * characters and the ending point must be a "T" character. Free spaces must be an empty space, " ". """ # read the grid and set up stack grid = maze_reader(maze) print("maze without attempts:\n", grid) if data_structure == 'stack': _queue = LinkedStack() else: _queue = LinkedQueue( ) #TODO implement a linkedQueue structure with push _queue.push(start) # track choices: choice_count = 0 #use stack data structure to explore maze and find a path to the end. while not _queue.isEmpty(): _pop = _queue.pop() # print("popping ",_pop) if grid[_pop[0]][_pop[1]] == 'T': choice_count += 1 print("Finished maze: \n") print(grid) if to_text: maze_text(grid, "solution.txt") return choice_count else: # if the _pop location did not return the character "T", leave a breadcrumb to not revisit. if grid[_pop[0]][_pop[1]] != 'O' and grid[_pop[0]][ _pop[1]] != 'T' and grid[_pop[0]][_pop[1]] != 'P': choice_count += 1 grid[_pop[0]][_pop[1]] = 'O' # print("grid row, column is ",_pop[0],_pop[1],"\n") # print(grid) left = grid[_pop[0]][(_pop[1] - 1)] right = grid[_pop[0]][(_pop[1] + 1)] down = grid[(_pop[0] - 1)][_pop[1]] up = grid[(_pop[0] + 1)][_pop[1]] if left == ' ' or left == 'T': _queue.push((_pop[0], (_pop[1] - 1))) if right == ' ' or right == 'T': _queue.push((_pop[0], (_pop[1] + 1))) if up == ' ' or up == 'T': _queue.push(((_pop[0] + 1), _pop[1])) if down == ' ' or down == 'T': _queue.push(((_pop[0] - 1), _pop[1])) #if stack becomes empty, there is no path. return choice_count
def levelorder(self): """Supports a levelorder traversal on a view of self.""" lyst = list() # need a first in first out order, so use LinkedQueue # add self._root to get while loop started nodeStack = LinkedQueue([self._root]) while nodeStack: currentNode = nodeStack.pop() lyst.append(currentNode.data) if currentNode.left: nodeStack.add(currentNode.left) if currentNode.right: nodeStack.add(currentNode.right) return iter(lyst)
def levelorder(self): """Supports a levelorder traversal on a view of self.""" our_list = [] our_queue = LinkedQueue() def recurse(): if not our_queue.isEmpty(): node = our_queue.pop() our_list.append(node.data) if node.left is not None: our_queue.add(node.left) if node.right is not None: our_queue.add(node.right) recurse() if not self.isEmpty(): our_queue.add(self._root) recurse() return iter(our_list)
def test_emptylinkedqueue_front(self): queue = LinkedQueue() val = queue.front()
import unittest from linkedqueue import LinkedQueue q = LinkedQueue() for i in range(7): q.add(i + 1) class UnitTests(unittest.TestCase): def test_unit_test(self): self.assertEqual(len(q), 7) q.clear() self.assertEqual(len(q), 0)
def __init__(self): self.stack1 = LinkedQueue() self.stack2 = LinkedQueue()
def test_linkedqueue_ctor(self): queue = LinkedQueue() assert_equal(0, len(queue))
def stack_to_queue(StackObj): """ takes a stack and transformes it to queue""" queue = LinkedQueue() for el in StackObj: queue.add(el) return queue
def test_emptylinkedqueue_dequeue(self): queue = LinkedQueue() val = queue.dequeue()
def __init__(self): self.queue = LinkedQueue()
def breadthFirstTraverse(graph, startVertex, process): traverseFromVertex(graph, startVertex, process, LinkedQueue())
def newQueue(self): return LinkedQueue()
def __init__(self): self._total_customer_wait_time = 0 self._customers_served = 0 self._current_customer = None self._queue = LinkedQueue()
def test_linkedqueue_enqueue(self): queue = LinkedQueue() for i in range(100): queue.enqueue(i + 1) assert_equal(1, queue.front()) assert_equal(100, len(queue))