Example #1
0
 def test_queue_enqueue(self):
     queue = Queue()
     queue.enqueue(25)
     self.assertIsNotNone(queue)
     self.assertTrue(queue.__len__() == 1)
     queue.enqueue("Riccardo")
     self.assertTrue(queue.__len__() == 2)
     self.assertTrue(queue.head.item == 25)
     self.assertFalse(queue.head.next.item == 25)
     self.assertTrue(queue.head.next.item == "Riccardo")
Example #2
0
    def bft_print(self):
        q = Queue()
        visited = []

        # print(dir(q))

        def rec(tree):
            if tree.value not in visited:
                q.enqueue(tree.value)
                visited.append(tree.value)
            if tree.left:
                q.enqueue(tree.left.value)
                visited.append(tree.left.value)
            if tree.right:
                q.enqueue(tree.right.value)
                visited.append(tree.right.value)
            if tree.left:
                rec(tree.left)
            if tree.right:
                rec(tree.right)

        rec(self)

        string = ''
        for x in range(q.__len__()):

            string += f'{q.dequeue()}\n'
            # print(value)

        print(string)
        return string
        pass
Example #3
0
    def bft_print(self, node):
        # You should import the queue class from earlier in the
        # week and use that class to implement this method
        # Use a queue to form a "line"
        # for the nodes to "get in"

        # start by placing the root in the queue

        # need a while loop to iterate
        # what are we checking in the while statement?
        # while length of queue is greater than 0
        # dequeue item from front of queue
        # print that item

        # place current item's left node in queue if not None
        # place current item's right node in queue if not None
        queue = Queue()
        if self:
            queue.enqueue(self)
        while queue.__len__() > 0:
            current_node = queue.dequeue()
            print(current_node.value)
            if current_node.left != None:
                queue.enqueue(current_node.left)
            if current_node.right != None:
                queue.enqueue(current_node.right)
Example #4
0
 def test_queue_dequeue(self):
     queue = Queue()
     queue.enqueue(25)
     queue.enqueue("Riccardo")
     queue.enqueue("Try")
     self.assertIsNotNone(queue)
     self.assertTrue(queue.__len__() == 3)
     queue.dequeue()
     self.assertTrue(queue.__len__() == 2)
     self.assertTrue(queue.head.item == "Riccardo")
     self.assertFalse(queue.head.next.item == 25)
     self.assertTrue(queue.head.next.item == "Try")
     queue.dequeue()
     self.assertTrue(queue.head.item == "Try")
     self.assertTrue(queue.head.next is None)
     item = queue.dequeue()
     self.assertTrue(item == "Try")
     self.assertTrue(queue.head is None)
    def bft_print(self, node):
        bft_queue = Queue()
        bft_queue.enqueue(node)

        while bft_queue.__len__() != 0:
            current_node = bft_queue.dequeue()
            if current_node.left is not None:
                bft_queue.enqueue(current_node.left)
            if current_node.right is not None:
                bft_queue.enqueue(current_node.right)
            print(current_node.value)
Example #6
0
    def bft_print(self):
        q = Queue()
        q.enqueue(self)

        while q.__len__() != 0:
            current = q.dequeue()
            print(current.value)
            if current.left is not None:
                q.enqueue(current.left)
                
            if current.right is not None:
                q.enqueue(current.right)
Example #7
0
    def test_length(self):

        # Arrange
        my_queue = Queue()
        my_queue.enqueue(1)
        my_queue.enqueue(2)

        # Act
        length1 = my_queue.__len__()

        # Assert
        self.assertEqual(2, length1, "length did not have the expected value")
Example #8
0
    def bft_print(self, node):
        # Use a queue to pass in values
        the_queue = Queue()
        the_queue.enqueue(node)  # Start queue with base node

        # while loop to get through the nodes in the queue
        # First in first out makes it so we move left to right on each level
        # as long as the order has left before right in the checks
        while the_queue.__len__() > 0:  # While there is anything in the queue
            current_node = the_queue.dequeue(
            )  # Take the first item from the queue
            print(current_node.value)  # Print the value of the new node
            if current_node.left:  # Check if there's a left branch
                the_queue.enqueue(current_node.left)  # Add it to the queue
            if current_node.right:  # Check if there's a right branch
                the_queue.enqueue(current_node.right)  # Add it to the queue
Example #9
0
 def bft_print(self, node):
     # create a queue for nodes
     queue = Queue()
     # add the first node to the queue
     queue.enqueue(node)
     # while queue is not empty
     while queue.__len__() != 0:
         # remove the first node from the queue
         removed = queue.dequeue()
         # print the removed node
         print(removed.value)
         # add all children into the queue
         if removed.right is not None:
             queue.enqueue(removed.right)
         if removed.left is not None:
             queue.enqueue(removed.left)
 def bft_print(self, node):
     # Use a queue to form a line
     # Start by place the root in the queue
     queue = Queue()
     queue.enqueue(node)
     # Need a while loop to interate
     # While length of queue is greater than 0
     while queue.__len__() > 0:
         # dequeue item from front if queue
         # print that item
         current = queue.dequeue()
         print(current.value)
         # place current items left node in queue if not None
         if current.left is not None:
             queue.enqueue(current.left)
         # place current items right nodein queue if not None
         if current.right is not None:
             queue.enqueue(current.right)
Example #11
0
 def test_queue_empty(self):
     queue = Queue()
     self.assertTrue(queue.__len__() == 0)
     self.assertEqual(queue.head, None)