def test_filled_queue(): queue = Queue() queue.add(1) assert queue.remove() == 1 queue.add(1).add(2).add(3) assert queue.remove() == 1 assert queue.remove() == 2
def find_path(node_a, node_b): if node_a == node_b: return True queue = Queue() queue.add(node_a) node_a.visited = True while not queue.is_empty(): children = queue.remove() if children: for child in children: if child.visited == False: child.visited = True if child == node_b: return True queue.add(child) children.visited = True return False
def test_add(self): queue = Queue() queue.add(1) self.assertEqual(1, queue.peek()) self.assertFalse(queue.isEmpty()) queue.add(2) queue.add(3) self.assertEqual(1, queue.peek())
def weave(q1, q2): q_out = Queue() while q1.peek() is not None or q2.peek() is not None: if q1.peek() is not None: q_out.add(q1.remove()) if q2.peek() is not None: q_out.add(q2.remove()) return q_out
class AnimalShelter: def __init__(self): self.cats = Queue() self.dogs = Queue() self.pos = 0 # Time complexity: O(1) # Space complexity: O(1) def enqueue(self, animal: Animal): if animal == Animal.cat: self.cats.add([animal, self.pos]) else: self.dogs.add([animal, self.pos]) self.pos += 1 return self # Time complexity: O(1) # Space complexity: O(1) def dequeue(self): if self.dogs.is_empty() and self.cats.is_empty(): raise Exception('no animal in shelter') if self.dogs.is_empty(): return self.cats.remove() if self.cats.is_empty(): return self.dogs.remove() dog_pos = self.dogs.peek()[1] cat_pos = self.cats.peek()[1] if cat_pos < dog_pos: return self.cats.remove() else: return self.dogs.remove() # Time complexity: O(1) # Space complexity: O(1) def dequeueCat(self): if self.cats.is_empty(): raise Exception('no cats in shelter') return self.cats.remove() # Time complexity: O(1) # Space complexity: O(1) def dequeueDog(self): if self.dogs.is_empty(): raise Exception('no dogs in shelter') return self.dogs.remove() def __str__(self): return 'cats: ' + str(self.cats) + '\ndogs: ' + str(self.dogs)
def test_remove(self): queue = Queue() queue.add(1) self.assertEqual(1, queue.remove()) self.assertTrue(queue.isEmpty()) queue.add(2) queue.add(3) self.assertEqual(2, queue.remove()) self.assertEqual(3, queue.remove()) self.assertTrue(queue.isEmpty())
def main(): values = Queue() values.add(0) values.add(1) values.add(2) values.add(3) print(values.peek() == 0) print(values.length == 4) print(values.pop() == 0) print(values.pop() == 1) print(values.pop() == 2) print(values.pop() == 3) print(values.is_empty())
def generate_queue(file): f = open(file, "r") lines = f.readlines() f.close queue = Queue() for line in lines: queue.add(line.strip()) return queue # print generate_queue("../static/puzzles.txt")
def test_uneven_weave(self): q1 = Queue() q1.add(2) q1.add(3) q1.add(4) q1.add(6) q1.add(7) q2 = Queue() q2.add("Hi") q2.add("Ho") q2.add("He") self.assertEqual( weave(q1, q2).array, [7, 6, "He", 4, "Ho", 3, "Hi", 2])
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()
def answer(a): #使用一个栈从两个方向获取数值 c = Queue() b = Stack() cur = a.element() while cur != None: b.push(Node(cur.value)) cur = cur.next c = Queue() a_pre = a.element() add_a_pre = False # queue length is odd while a.element().value != b.peek().value and \ a_pre.value != b.peek().value: if a_pre.value == b.peek().value: add_a_pre = True a_pre = a.remove() c.add(Node(a_pre.value)) c.add(Node(b.pop().value)) if add_a_pre: # odd c.add(Node(a_pre.value)) else: # even c.add(Node(a.remove().value)) return c
def spin(alist, marker): circle = Queue() for student in alist: circle.add(student) while len(circle) > 1: for round in range(marker): circle.add(circle.remove()) circle.remove() return circle[0]
def breadth_first_search(value, root): """Using a Queue""" queue = Queue() queue.add(root) while queue.queue: node = queue.remove() print(node) if node.data == value: return True else: for child in node.children: queue.add(child) return False
def test_equal_weave(self): q1 = Queue() q1.add(3) q1.add(4) q1.add(6) q2 = Queue() q2.add("Hi") q2.add("Ho") q2.add("He") self.assertEqual(weave(q1, q2).array, ["He", 6, "Ho", 4, "Hi", 3])
class Character: def __init__(self, move_list, speed): self.move_list = move_list self.speed = speed self.move_queue = Queue() def queue_move(self, move): self.move_queue.add(move) def perform_move(self): move = self.move_queue.remove() def start(self): while (self.move_queue.empty() == False): seconds = floor((20 / self.speed)) time.sleep(seconds) action = self.move_queue.remove() print('Performing Action:', action)
def BFS(start, end): queue = Queue() queue.add(start) visited_set = {} visited_set[start.label] = True while not queue.is_empty(): current = queue.remove() for i in range(current.neighbors_num): node = current.neighbors[i] if not visited_set.has_key(node.label): visited_set[node.label] = True if node.label == end.label: return True else: queue.add(node) return False
def __repr__(self): """String representation.""" queue = Queue() self.marked = True queue.add(self) s = '' counter = 1 depth = 0 while not queue.is_empty(): r = queue.remove() s += str(r.name) s += '\t' if counter == 2**depth: s += '\n' counter = 0 depth += 1 counter += 1 if r.left is not None: if r.left.marked == False: r.left.marked = True queue.add(r.left) if r.right is not None: if r.right.marked == False: r.right.marked = True queue.add(r.right) return s
def answer3(a): #使用快慢指针来均分链表, 然后把后面一半倒序, 拆分为2个队列,上看去更简洁 slow = fast = a.first pre = None while fast: pre = slow slow = slow.next if fast.next: fast = fast.next.next else: fast = fast.next if fast == a.last: break; pre.next = None a.last = pre b = Queue() while slow: b.add(slow) slow = slow.next import reverse_list b2 = reverse_list.answer(b) r = Queue() while a.element() and b.element() : r.add(Node(a.remove().value)) r.add(Node(b.remove().value)) if b.element(): r.add(Node(b.remove().value)) return r
def answer2(a): #使用快慢指针来均分链表, 然后把后面一半倒序 slow = fast = a.first while fast: slow = slow.next if fast.next: fast = fast.next.next else: fast = fast.next if fast == a.last: break; mid = slow b = Queue() while slow: b.add(slow) slow = slow.next import reverse_list b2 = reverse_list.answer(b) r = Queue() _a = a.first _b = b.first while _a.value != mid.value: r.add(Node(_a.value)) r.add(Node(_b.value)) _a = _a.next _b = _b.next if _b: r.add(Node(_b.value)) return r
def main(): employee_directory = [] sudo_usernames_data = [ "Inger Hella", "Saga Janina", "Alfred Dorotea", "Tessan Helen", "Michael Rigmor", "Edith Ida", "John Henrike", "Hella Lukas", "Thyra Karolina", "Øyvind Nathalie", "Miroslav Tikhon", "Tòmas Prokhor", "Timofei Vitaliy", "Beileag Logan", "Filipp Vadim", "Ruaridh Lilia", "Filat Svyatoslav", "Sofiya Bhaltair", "Max Saveli", "Yeva Snezhana" ] for i, val in enumerate(sudo_usernames_data): # output = f'{i} {val} {random.randrange(100,999)} {predict_shift[random.randrange(1,4)]}' employee_directory.append( Employee(val, random.randrange(100, 999), random.randrange(1, 4))) # print(employee_directory[i].to_string()) print("Before id number sort: \n ----------") EmployeeArrayUtilities.print_array(employee_directory) array_size = len(employee_directory) EmployeeArrayUtilities.print_array(employee_directory, "\nBefore last-name sort:") EmployeeArrayUtilities.sort_array(employee_directory, array_size) EmployeeArrayUtilities.print_array(employee_directory, "\nAfter last-name sort: ") s1 = Queue(10, Employee()) print("Enter an employee number to add to the queue: ", end="") new_search_value = input() # s1 = Queue(10, 0) found = EmployeeArrayUtilities.binary_search_number( employee_directory, int(new_search_value), 0, array_size - 1) # print("found: ", found) if found != EmployeeArrayUtilities.NOT_FOUND: print(new_search_value + " IS in list at position " + str(found)) else: print(new_search_value + " is NOT in list.") # print("capacity: ", s1.get_capacity()) # print(employee_directory[0]) # s1.add(employee_directory[0]) # s1.add(employee_directory[1]) # s1.add(employee_directory[2]) # s1.add(employee_directory[3]) # s1.add(employee_directory[4]) s1.add(1) s1.add(2) s1.add(3) s1.add(4) s1.add(5) s1.add(6) print(s1.que) for k in range(0, 3): print("[" + str(s1.remove()) + "]") print(s1.que)
def main(): students = [Student(student_id) for student_id in range(1, 10)] print_queue = Queue() print("\n\t\tPrinter Initiated") for student in students: tasks_list = [Task(), Task()] student.addTasks(tasks_list) print_queue.add(student) while not bool(print_queue): student_tasks = print_queue.remove() tasks = student_tasks.tasks for task in range(len(tasks)): printer = Printer() print("\n\t---PRINTING!!--") if printer.isBusy(): printer.task = tasks[task] printer.print() current_status = QueueStatus(print_queue, printer) print("Printing Student {0} task:{1}".format( student_tasks.id, task + 1)) print("Total pages: ", current_status[1]) print("Average waiting time {0} min".format(current_status[0])) if printer.taskCompleted(): print("Current Task Print Completed") else: print( "Printer is busy, will update you the status very shortly " ) print("ALL TASKS HAVE PRINTED")
def serialize_tree(tree): tree_list = [] queue = Queue() queue.add(tree) while queue.queue: node = queue.remove() if node is None: tree_list.append(-1) else: tree_list.append(node.data) if node.left: queue.add(node.left) else: queue.add(None) if node.right: queue.add(node.right) else: queue.add(None) return tree_list
class Animal_Queue(object): def __init__(self): self.dog_queue = Queue() self.cat_queue = Queue() self.time = 0 def enqueue(self, animal): animal.order = self.time self.time += 1 if animal.kind == 'dog': self.dog_queue.add(animal) else: self.cat_queue.add(animal) def dequeue_any(self): if self.dog_queue.front().order < self.cat_queue.front().order: self.dog_queue.remove() else: self.cat_queue.remove() def dequeue_dog(self): self.dog_queue.remove() def dequeue_cat(self): self.cat_queue.remove() def print_animal_queue(self): print '[', for i in range(self.dog_queue.size): print self.dog_queue.list[i].name, print ']' print '[', for i in range(self.cat_queue.size): print self.cat_queue.list[i].name, print ']'
def answer(a, b): c = Queue() carry = 0 while a.element() != None and b.element() != None: sum = a.remove().value + b.remove().value + carry c.add(Node(sum%10)) carry = sum/10 while a.element() != None: sum = a.remove().value + carry c.add(Node(sum%10)) carry = sum/10 while b.element() != None: sum = b.remove().value + carry c.add(Node(sum%10)) carry = sum/10 if carry > 0: c.add(Node(carry)) return c
def main(): print("Queue") print("Creating an empty queue") q = Queue() print("Add 2 to queue") q.add(2) q.print_queue() print("Add 8 to queue") q.add(8) print("Add 5 to queue") q.add(5) print("Add 90 to queue") q.add(90) q.print_queue() print("Queue length:",len(q)) print("Now serve the first item in queue") q.serve() q.print_queue()
def __str__(self): queue = Queue() queue.add(self.root) values = [] while not queue.is_empty(): exp = queue.remove() values.append(str(exp.value)) if exp.value.left: queue.add(exp.value.left) if exp.value.right: queue.add(exp.value.right) return str(values)
def test_queue(N): print("Testing queue") q = Queue() print("Check if empty") print(q.empty()) print(f"Adding {N} values") [q.add(i) for i in range(N)] print("") print("Peeking front value") print(q.peek()) print("Removing values") [q.remove() for i in range(int(N / 2) - 1)] print("Mid-value:") print(q.remove()) [q.remove() for i in range(int(N / 2))] print("Queue should now be empty") try: q.remove() except Exception: print("Got expected Exception")
def breadth_first_search(value, root): """Using a Queue""" queue = Queue() queue.add(root) while queue.queue: node = queue.remove() print(node) if node.data == value: return True else: if node.left: queue.add(node.left) if node.right: queue.add(node.right) return False
def BFS(node): queue=Queue() queue.add(node) visited=set() visited.add(node) while not queue.is_empty(): r=queue.remove() print(r.value) if r.left!=None: if r.left not in visited: queue.add(r.left) visited.add(r.left) if r.right!=None: if r.right not in visited: queue.add(r.right) visited.add(r.right)
def list_of_depths(bt: BinarySearchTree): nodes = {} que = Queue() que.add([bt.root, 1]) while not que.is_empty(): (node, pos) = que.remove().value if not nodes.get(pos): nodes[pos] = LinkedList() nodes[pos].unshift(node.value) if node.left: que.add([node.left, pos + 1]) if node.right: que.add([node.right, pos + 1]) return nodes
def check_if_binary_search_tree(root): """Using a Queue""" queue = Queue() queue.add(root) while queue.queue: node = queue.remove() print(node) if node.left: # If left node, check it is smaller if node.left.data < node.data: queue.add(node.left) else: return False if node.right: # If right node, check it is greater if node.right.data > node.data: queue.add(node.right) else: return False return True
def demo(): a = Queue() a.add(Node(2)); a.add(Node(4)); a.add(Node(5)) print a b = Queue() b.add(Node(5)); b.add(Node(6)); b.add(Node(4)) print b c = answer(a, b) print c
def test_remove(self): q = Queue() q.add(3) q.add(4) q.add(6) self.assertEqual(q.remove(), 3)
def test_add(self): q = Queue() q.add(3) q.add(4) q.add(6) self.assertEqual(q.array, [6, 4, 3])
from queue import Queue queue = Queue() queue.add('a') queue.add('b') queue.add('c') print queue.isEmpty() print queue.poll() print queue.poll() print queue.poll() print queue.isEmpty() print queue.poll()
ser = serial.Serial('', 9600) time.sleep(1) s = set() q = Queue() BASE_URL = 'http://13.66.209.37:3000' states = ['DispenseCup', 'DispensePearls', 'DispenseTea'] while 1: r = requests.get(BASE_URL+'/orders/') json = r.json() for item in json: if item['id'] is not in s: s.add(item['id']) q.add(item) robot = requests.get(BASE_URL+'/robots') robot = robot.json()[0] # if robot['state'] in states: if robot['ack']: serial.write(robot['state']) rob = requests.patch(BASE_URL + '/robots/' + robot['id'], json = {'ack': False, 'state': states[(states.index(robot['state']) + 1 ) % len(states)]}, headers = {'Content-Type': 'application/json'}) time.sleep(3)
class AutoDrone (Drone, Thread): """ AR Drone 2.0 qui suit une cible à l'aide de la caméra avant. Classe abstraite. """ __metaclass__ = ABCMeta CAM_RES = (640,360) VID_PORT = 5555 # Frames per cmd -> combien de frames on attend pour envoyer une commande DEF_FPC = 3 DEF_MIN_SPEED = 0.2 DEF_MAX_SPEED = 2 # La distance initiale de la caméra du drone à la cible, en m DEF_INITIAL_D = 1 # Contrôleur proportionnel KP_X = 2 KP_Y = 2 KP_Z = 0.8 # Contrôleur intégral KI_X = 0.1 KI_Y = 0.1 KI_Z = 0.1 # Contrôleur dérivée KD_X = 1 KD_Y = 1 KD_Z = 1 def __init__(self, stopped, min_speed=DEF_MIN_SPEED, max_speed=DEF_MAX_SPEED, verbosity=Drone.QUIET, fpc=DEF_FPC, initial_d=DEF_INITIAL_D): """ [stopped] -> cf Drone. [min_speed] et [max_speed] -> Les vitesses min et max que l'on peut avoir en donnant des ordres au drone (selon le drone). [verbosity] -> cf Drone. [fpc] -> Le nombre d'images que l'on attend avant d'envoyer une commande (règle la précision et la réactivité). [initial_d] -> La distance initiale entre la cible et le drone lors de sa sélection (pour se déplacer en avant et en arrière). [mode] -> Selon si l'on choisit nous-même la zone d'image à suivre ou si le drone le fait automatiquement. """ Drone.__init__(self, stopped, max_speed, verbosity) Thread.__init__(self) self.min_speed = min_speed self.max_speed = max_speed self.tracking = False self.queue = Queue(self, fpc) self.frontCam() self.initial_d = initial_d self._autoMove_last_t = datetime.now() # Contrôleur PID self.pid_x = PID(kp=AutoDrone.KP_X, ki=AutoDrone.KI_X, kd=AutoDrone.KD_X) self.pid_y = PID(kp=AutoDrone.KP_Y, ki=AutoDrone.KI_Y, kd=AutoDrone.KD_Y) self.pid_z = PID(kp=AutoDrone.KP_Z, ki=AutoDrone.KI_Z, kd=AutoDrone.KD_Z) ################################################################################################################ ################################################ Vidéo ########################################## ################################################################################################################ def bottomCam(self): """ Demande au drone de laisser sur le port vidéo le flux de la caméra du bas. """ self.config("video:video_channel", "1") print "Choice : bottom camera" def frontCam(self): """ Demande au drone de laisser sur le port vidéo le flux de la caméra du haut. """ self.config("video:video_channel", "0") print "Choice : front camera" def enableCam(self): """ Tenter de récupérer le flux sur le port vidéo. """ self.cam = cv2.VideoCapture( 'tcp://{0}:{1}'.format(Drone.IP, AutoDrone.VID_PORT) ) if not self.cam.isOpened(): print "Drone camera not reachable" return False print "Drone camera OK" return True def releaseCam(self): self.cam.release() def viewCam(self): """ Regarder le stream video en temps réel. """ cont, frame = self.cam.read() while cont: cv2.imshow('cam', frame) cont, frame = self.cam.read() if (cv2.waitKey(1) & 0xFF) == ord('q'): cont = False cv2.destroyAllWindows() ################################################################################################################ ########################################## Déplacement autonome ################################## ################################################################################################################ def autoMove(self, roi): """ [roi] est la zone de l'image où se situe l'objet à suivre. Extrapôle le décalage en x,y,z par rapport à la position idéale, et la fournit à la file d'attente. Les vitesses en x,y,z sont régulées grâce à un contrôleur PID. """ mid_x = roi[0] + 0.5*roi[2] mid_y = roi[1] + 0.5*roi[3] # Prélèvement du temps t = datetime.now() delta_t = (t - self._autoMove_last_t).total_seconds() self._autoMove_last_t = t error_x = mid_x - self.ideal_center[0] error_y = self.ideal_center[1] - mid_y # Pour x et y, c'est simple : on regarde l'éloignement par rapport au centre de la frame et on y applique un correcteur PID x_speed = self.pid_x.getOrder(error_x, delta_t) / AutoDrone.CAM_RES[0] y_speed = self.pid_y.getOrder(error_y, delta_t) / AutoDrone.CAM_RES[1] # Pour z, -> cf doc. (formule de trigo). On fait la moyenne des quotients sur x et sur y. z_speed = 0 if roi[2] != 0 and roi[3] != 0: d = self.initial_d * ( self.ideal_target[2] / roi[2] + self.ideal_target[3] / roi[3] )/2 error_z = d - self.initial_d z_speed = self.pid_z.getOrder(error_z, delta_t) verif = lambda x : x if -1 < x < 1 else (1.0 if x>0 else -1.0) x_speed,y_speed,z_speed = map(verif, (x_speed, y_speed, z_speed)) self.queue.add((x_speed,y_speed,z_speed)) self.queue.check() def processVector(self, vector): print "{} {} {}".format(vector.x, vector.y, vector.z) self.move(False, 0, vector.z, vector.y, vector.x) # DBG #self.move(False, 0, vector.z, 0, 0) @abstractmethod def initROI(self): pass def showGUI(self, frame, roi): """ Par défaut, on affiche la zone détectée. """ frame_copy = deepcopy(frame) cv2.rectangle(frame_copy, (int(roi[0]), int(roi[1])), (int(roi[2]+roi[0]), int(roi[3]+roi[1])), (0,0,255), thickness=7) cv2.rectangle( frame_copy, (self.ideal_target[0], self.ideal_target[1]), (self.ideal_target[0]+self.ideal_target[2], self.ideal_target[1]+self.ideal_target[3]), (0,255,0), thickness=7 ) cv2.imshow("Drone camera", frame_copy) if cv2.waitKey(1) & 0xFF == ord('q'): self.tracking= False def run(self): """ Globalement, ce que fait la fonction: /////// Initialisation /////// + on choisit la zone d'image (ROI en anglais) manuellement ou automatiquement, qui sera la zone à suivre pendant la suite. (1) + on définit à partir de la ROI choisie la cible parfaite (dimensions initialies et située au centre de l'écran). (2) + on suit la cible à l'aide d'un algorithme de traçage, appelé MedianFlow. (3) /////// En boucle /////// + on récupère la position de l'objet à traçer, puis on la compare à la position idéale et on bouge en fonction. (4) + on vérifie qu'il n'y ait pas trop de latence, sinon on supprime les commandes trop anciennes.(5) """ if hasattr(self, 'cam'): self.releaseCam() self.tracking = self.enableCam() #1 self.initROI() #2 self.ideal_target = (int( (AutoDrone.CAM_RES[0]-roi[2])/2 ), int( (AutoDrone.CAM_RES[1]-roi[3])/2 ), int(roi[2]), int(roi[3])) self.ideal_center = (self.ideal_target[0] + self.ideal_target[2]/2, self.ideal_target[1] + self.ideal_target[3]/2) self.ideal_area = self.ideal_target[2]*self.ideal_target[3] #3 tracker = cv2.TrackerMedianFlow_create() if self.tracking: self.tracking = tracker.init(frame, roi) while self.tracking: check_time = datetime.now() #4 self.autoMove(roi) self.showGUI(frame, roi) _, roi = tracker.update(frame) if self.tracking: self.tracking, frame = self.cam.read() #5 latency = (datetime.now() - check_time).total_seconds() if latency >= 1.0: self.queue.empty() print "WARNING : REALLY TOO SLOW!!!" if latency >= 0.2: print "WARNING : high latency : {} s.".format(latency) def inactivate(self): self.tracking = False Drone.inactivate(self) self.releaseCam()
class Scheduler(Thread): file_semaphore = Semaphore() def __init__(self,controller,dispatch,error): Thread.__init__(self) self.policy = policy.get_policy() self.controller = controller self.do_dispatch = dispatch self.error = error self.queue = Queue() self.queue.load() self.lock = Lock() self._quit = Event() self.add_queue = SyncQueue(0) self.num_run = 0 self.log = get_logger() def job(self,id): return self.queue.get(id) def jobs(self): return self.queue.get() def save(self): self.queue.save() def add(self,item): if self.lock.acquire(0): self.queue.add(item) self.lock.release() else: self.add_queue.put(item) def add_url(self,url,referer=None): try: fd = urlopen(url,referer=referer) meta = fd.read() fullurl = fd.geturl() fd.close() save_torrent = 1 if fullurl.startswith('file://'): torrent_file = urllib.unquote(url) if torrent_file.startswith('file://'): torrent_file = torrent_file[7:] elif fullurl.startswith('file:/') and fullurl[8] == '|': torrent_file = urllib.unquote(url) torrent_file = torrent_file[7]+':'+torrent_file[9:] if torrent_file.find('Temporary Internet Files') >= 0: filename = os.path.split(url)[1] torrent_file = os.path.join(self.policy(policy.TORRENT_PATH), filename) else: filename = urllib.unquote(os.path.split(url)[1]) torrent_file = os.path.join(self.policy(policy.TORRENT_PATH), filename) torrent_path = os.path.dirname(torrent_file) if not os.path.exists(torrent_path): os.mkdir(torrent_path) if save_torrent: fd = open(torrent_file,'wb') fd.write(meta) fd.close() #~ d = Download() #cbt try: #cbt rd = bdecode(meta) #cbt if rd['cbt_user'] == self.policy(policy.CBT_LOGIN): #cbt dest_path = rd['cbt_path'] #cbt except: #cbt dest_path = self.policy(policy.DEST_PATH) #cbt self.add(QueueEntry(torrent_file, dest_path=dest_path)) #cbt except Exception,why: return str(why)
from stack import Stack from queue import Queue if __name__ == '__main__': print 'Stack' stack = Stack() name = 'Maikel Maciel Ronnau' [stack.push(x) for x in name] for x in name: print stack.pop().data, print print '\nQueue' queue = Queue() name = 'Maikel Maciel Ronnau' [queue.add(x) for x in name] for x in name: print queue.remove().data,
def demo(): a = Queue() a.add(Node(1)); a.add(Node(2)); a.add(Node(3)); a.add(Node(4)); a.add(Node(5)) print a print answer(a)