Esempio n. 1
0
 def bfs(self):
     self.clear()
     self._display_grid()
     # frontier is where we've yet to go
     frontier: Queue[Node[T]] = Queue()
     frontier.push(Node(self.start, None))
     # explored is where we've been
     explored: Set[T] = {self.start}
     self.step(frontier, explored, None)
Esempio n. 2
0
class TestQueue(TestStack):

    # inherit from testStack since similar tests will be run with Queue
    def setUp(self):
        self.structure = Queue()

    def test_structure_peek(self):
        structure = self.add_to_structure(
            self, iter(['people', 'potatoes', 'pansies']))
        # first word to the queue appears with peak
        self.assertEqual(self.structure.peek(), 'people')

    def test_structure_get(self):
        structure = self.add_to_structure(self, range(3))

        # test that last in are first out
        for i in range(3):
            self.assertEqual(self.structure.get(), i)
Esempio n. 3
0
def test_push():
    queue = Queue()
    assert (queue.is_empty())
    for i in range(ITERS):
        queue.push(i)
        assert (len(queue) == i + 1)
        assert (queue.peek() == 0)
        assert (not queue.is_empty())
    def test_peek(self):
        q = Queue(1)
        q.enqueue(2)
        q.enqueue(5)

        self.assertEqual(q.peek(), 1)

        q = Queue()  # empty queue
        self.assertRaises(IndexError, q.peek)  # supposed to raise IndexError
    def test_enqueue(self):
        q = Queue()
        q.enqueue(1)
        q.enqueue(2)
        q.enqueue(3)

        self.assertEqual(len(q), 3)
Esempio n. 6
0
    def bfs(self, starting_room, target_room):
        """
        Return a list containing the shortest path from starting_room to destination_room, 
        after searching for and finding it with a breadth-first search (BFS) algorithm.
        """
        # Initialize empty queue and set of BFS-"visited" rooms:
        queue = Queue()
        visited_bfs = set()

        # Initialize path (we will add the rest of the path from starting room to target room below):
        path_rooms = [starting_room]
        path_directions = []

        # Check if provided starting room is in our map:
        if starting_room in self.rooms.keys():
            # If so, add starting room to queue:
            queue.enqueue((path_rooms, path_directions))
        else:
            return IndexError(
                f"Provided starting room {starting_room} does not exist in map!"
            )

        # Search all rooms via BFS, logging their paths (from starting_room --> room) as we go:
        while queue.size() > 0:
            # Get next room to process as first item in queue:
            current_path_rooms, current_path_directions = queue.dequeue()
            current_room = current_path_rooms[-1]

            # Check if it is the target --> if so, return its full path:
            if current_room == target_room:
                return current_path_directions  # Alternative: return (current_path_rooms, current_path_directions)

            # If the current room has not already been visited+processed, check and process it:
            if current_room not in visited_bfs and current_room in self.rooms:
                # If not, then get its neighbor rooms and add their paths to the queue for future processing:s
                neighbors = self.get_neighbors(current_room)
                for adjacent_room_direction in neighbors:
                    adjacent_room_path_rooms = current_path_rooms + [
                        neighbors[adjacent_room_direction]
                    ]
                    adjacent_room_path_directions = current_path_directions + [
                        adjacent_room_direction
                    ]
                    queue.enqueue((adjacent_room_path_rooms,
                                   adjacent_room_path_directions))
                # Mark current room as "visited" by adding to our set of visited rooms:
                visited_bfs.add(current_room)

        # If no path found in entire map, return None:
        return None
Esempio n. 7
0
    def setUp(self):

        self.grid = np.genfromtxt("data_np.txt", delimiter=",", dtype=np.int)
        self.start = (4, 0)
        self.end = (0, 4)

        self.dfs_correct_returns = {
            "visited_list": [(4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (3, 4),
                             (3, 3), (3, 2), (2, 3), (2, 4), (1, 4), (0, 4)],
            "path_list": [(0, 4), (1, 4), (2, 4), (2, 3), (3, 3), (3, 4),
                          (4, 4), (4, 3), (4, 2), (4, 1), (4, 0)]
        }
        self.bfs_correct_returns = {
            "visited_list": [(4, 0), (3, 0), (4, 1), (4, 2), (3, 2), (4, 3),
                             (3, 3), (4, 4), (2, 3), (3, 4), (2, 4), (1, 4),
                             (0, 4)],
            "path_list": [(0, 4), (1, 4), (2, 4), (2, 3), (3, 3), (3, 2),
                          (4, 2), (4, 1), (4, 0)]
        }

        self.a_star_correct_returns = {
            "visited_list": [(4, 0), (3, 0), (4, 1), (3, 2), (2, 3), (1, 4),
                             (0, 4)],
            "path_list": [(0, 4), (1, 4), (2, 3), (3, 2), (4, 1), (4, 0)]
        }

        self.test_nodes = [
            Node(self.grid, (4, 0), cost=0, heuristic=12),
            Node(self.grid, (3, 0), cost=10, heuristic=10),
            Node(self.grid, (4, 1), cost=10, heuristic=8)
        ]

        self.maze = Maze(self.grid)
        self.priority_queue = PriorityQueue()
        self.stack = Stack()
        self.queue = Queue()
        self.visited = VisitedNodes()
Esempio n. 8
0
def test_stacks_to_queues():
    print('{}'.format('-' * 20))
    print('Start of Task 1 Testing (stacks_to_queues):\n')

    cases = [[1, 2, 3], [], [10, 20], [100, 200, 300, 400]]
    sizes = [3, 1, 2, 4]
    master_stack1 = Stack(len(cases))
    for i in range(len(cases) - 1, -1, -1):
        stack = Stack(sizes[i])
        for item in cases[i]:
            stack.push(item)
        master_stack1.push(stack)

    print('master_stack before calling function:')
    print(master_stack1)
    print()

    print('master_queue1 after calling function:')
    master_queue1 = stacks_to_queues(master_stack1)
    print(master_queue1)
    print()

    print('Verity that master_stack1 is empty after calling function:')
    print(master_stack1)

    print()
    print('Verifying Sizes:')
    counter = 0
    while not master_queue1.is_empty():
        print('Queue {} size = {}'.format(counter,
                                          master_queue1.remove()._size))
        counter += 1
    print()

    master_queue2 = stacks_to_queues(Stack(5))
    print('Contents of master_queue if master_stack is empty: {}'.format(
        master_queue2))
    print('Size of master_queue2 = {}'.format(master_queue2._size))
    print()

    master_queue3 = stacks_to_queues(Queue(5))
    print('Contents of master_queue if master_stack is invalid: {}'.format(
        master_queue3))
    print('Size of master_queue3 = {}'.format(master_queue2._size))
    print()

    print('End of Task 1 testing')
    print('{}\n'.format('-' * 20))
    return
def bfs(graph: Graph, start_node: str, target_node: str, visited_nodes: set):
    queue = Queue()
    queue.enqueue(start_node)

    while not queue.is_empty():
        current = queue.deque()

        if current == target_node:
            return True

        adj = graph.get_edges_node(current)
        for node in adj:
            if node not in visited_nodes:

                queue.enqueue(node)
        visited_nodes.add(current)

    return False
    def test_queue_size_after_dequeue_on_complete_queue(self):
        queue = Queue()

        items = [3, 4, 1, 111, "abcd", "item 5"]

        for item in items:
            queue.enqueue(item)

        # Dequeue operation on complete queue
        for i in range(len(items)):
            queue.dequeue()

        self.assertEqual(queue.length, QUEUE_LENGTH_ZERO)
Esempio n. 11
0
    def bfs(self, starting_vertex, target_vertex):
        """
        Return a list containing the shortest path from starting_vertex to destination_vertex, 
        after searching for and finding it with a breadth-first search (BFS) algorithm.
        """
        # Initialize empty queue and set of visited nodes:
        queue = Queue()
        visited = set()

        # Initialize path (we will add the rest of the path from starting vertex to target vertex below):
        path = [starting_vertex]

        # Check if provided starting vertex is in our graph:
        if starting_vertex in self.vertices.keys():
            # If so, add starting vertex to queue:
            queue.enqueue(path)
        else:
            return IndexError(
                f"Provided starting vertex {starting_vertex} does not exist in graph!"
            )

        # Process all vertices via BFT:
        while queue.size() > 0:
            # Get next vertex to process as first item in queue:
            current_path = queue.dequeue()
            current_vertex = current_path[-1]
            # If the current vertex has not already been visited+processed, check and process it:
            if current_vertex not in visited:
                # Check if it is the target --> if so, return its full path:
                if current_vertex == target_vertex:
                    return current_path
                # If not, then get its neighbor vertices and add their paths to the queue for future processing:
                for adjacent_vertex in self.get_neighbors(current_vertex):
                    adjacent_vertex_path = current_path + [adjacent_vertex]
                    queue.enqueue(adjacent_vertex_path)
                # Mark current vertex as "visited" by adding to our set of visited vertices:
                visited.add(current_vertex)

        # If no path found in entire graph, return None:
        return None
Esempio n. 12
0
def test_queue():
    f = Queue()

    test_array = [i for i in range(100)]

    for i in test_array:
        f.enqueue(i)

    result = []

    while not f.is_empty():
        result.append(f.deque())

    assert test_array == result
Esempio n. 13
0
def bfs(grid:np.array,start:tuple,end:tuple) -> Tuple[list,list]:
    """ A function that searches for the shortest path in a grid using the Breadth-first-search algorithm

        This function searches through a grid searching for the shortest path using the Breadth-first-search algorithm.
        First a Queue (queue) object is created and the first node is pushed into it. A VisitedNodes (visited) object
        is created after. While there are objects in queue, the first object in the queue is removed and placed in
        visited. If the node's position is equal to the end, then a visited list and a path list is returned. Otherwise,
        each child of the node is iterated upon and checked to see if they are in visited or the queue, and if that
        child is accessible. If true, then that child node is pushed into the queue and the process repeats.

        Parameters
        ----------
            grid : np.array
                a numpy array detailing the grid
            start : tuple
                a tuple detailing the starting node's position
            end : tuple
                a tuple detailing the ending node's position
        Returns
        -------
            Tuple[list,list]
                A list of visited nodes and a list of nodes that are included in the path
    """

    if grid[start[0]][start[1]] == 1 or grid[end[0]][end[1]] == 1:
        return [None],[None]

    queue = Queue()
    queue.push(Node(grid,start))
    visited= VisitedNodes()

    while len(queue) > 0:
        node = queue.pop()
        visited._store_node(node)
        if node.pos == end:
            visited_list, path_list = visited.create_path(node.pos, start)
            return visited_list, path_list
        else:
            for child in node.children:
                if child["node"] not in visited.visited_nodes and child["node"] not in queue.queue_list and child["accessibility"]:
                    queue.push(Node(grid, child["node"], parent=node.pos))
    return [None],[None]
Esempio n. 14
0
def bfs(initial, goal_test, successors):
    """
    Breadth-first search.

    Parameters
    ----------
    initial : Generic
        Starting point of the search.
    goal_test : Callable
        Callable returing boolean value indicating search success.
    successors : Callable
        Callable returning list of next possible locations in search space.

    Returns
    -------
    found : Generic
        Node corresponding to successful goal_test.
        Returns None if search fails.
    """
    # References to candidate and previously-explored nodes in search space
    frontier = Queue()
    explored = Stack()

    # Initialize candidate search locations with initial condition
    frontier.push(Node(initial, None))

    # Continue search as long as their are candidates in the search space
    while not frontier.empty:
        current_node = frontier.pop()
        current_state = current_node.state
        # If current node meets goal, then search completes successfully
        if goal_test(current_state):
            return current_node
        # Populate next step in search
        for child in successors(current_state):
            # Skip previously-explored states
            if child in explored: 
                continue
            explored.push(child)
            frontier.push(Node(child, current_node))
    # Search terminates without finding goal
    return None
def simulation(num_seconds, pages_per_minute, num_students):
    lab_printer = Printer(pages_per_minute)
    print_queue = Queue()
    waiting_times = []

    for current_second in range(num_seconds):
        if new_print_task(num_students):
            task = Task(current_second)
            print_queue.enqueue(task)

        if (not lab_printer.busy()) and (not print_queue.is_empty()):
            nexttask = print_queue.dequeue()
            waiting_times.append(nexttask.wait_time(current_second))
            lab_printer.start_next(nexttask)

        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()))
Esempio n. 16
0
def simulation(seconds, ppm):
    printer = Printer(ppm)
    print_queue = Queue()
    waiting_times = []

    for sec in range(seconds):
        if is_new_task():
            task = Task(sec)
            print_queue.enqueue(task)

        if not printer.busy() and not print_queue.is_empty():
            next_task = print_queue.dequeue()
            waiting_times.append(next_task.wait_time(sec))
            printer.start_next(next_task)

        printer.tick()

    average_wait = sum(waiting_times) / len(waiting_times)
    print("Average Wait %6.2f secs %3d tasks remaining." %
          (average_wait, print_queue.size()))
def simulation(numSeconds, numStudents, pagesPerMinute):

    labprinter = Printer(pagesPerMinute)
    printQueue = Queue()
    waitingtimes = []

    for currentSecond in range(numSeconds):
        if newPrintTask(numStudents):
            task = Task(currentSecond)
            printQueue.enqueue(task)

        if (not labprinter.busy()) and (not printQueue.isEmpty()):
            nexttask = printQueue.dequeue()
            waitingtimes.append(nexttask.waitTime(currentSecond))
            labprinter.startNext(nexttask)

        labprinter.tick()

    averageWait = sum(waitingtimes) / len(waitingtimes)
    print("Average Wait %6.2f secs %3d tasks remaining." %
          (averageWait, printQueue.size()))
    return averageWait
Esempio n. 18
0
    def setUp(self):
        self.emptyQueue = Queue()
        self.Queue = Queue()

        for i in range(5):
            self.Queue.enqueue(i)
Esempio n. 19
0
class TestQueue(unittest.TestCase):  # FIFO

    def setUp(self):
        self.emptyQueue = Queue()
        self.Queue = Queue()

        for i in range(5):
            self.Queue.enqueue(i)

    def test_repr(self):
        '''Test returning the queue as a string literal.'''
        self.assertEqual(repr(self.emptyQueue), str(()))
        tup = (1, 3.14, 'foo', True)

        for i in tup:
            self.emptyQueue.enqueue(i)

        self.assertEqual(repr(self.emptyQueue), str(tup))

    def test_len_size(self):
        '''Test returning the size of the queue.'''
        for i in range(100):
            self.emptyQueue.enqueue(i)

        self.assertEqual(len(self.emptyQueue), 100)
        self.assertEqual(self.emptyQueue.size(), 100)

        self.emptyQueue.dequeue()
        self.assertEqual(len(self.emptyQueue), 99)
        self.assertEqual(self.emptyQueue.size(), 99)

    def test_tuple(self):
        '''Test returning the queue as a tuple literal.'''
        self.assertEqual(tuple(self.emptyQueue), ())
        tup = (1, 3.14, 'foo', True)

        for i in tup:
            self.emptyQueue.enqueue(i)

        self.assertEqual(tuple(self.emptyQueue), tup)

    def test_list(self):
        '''Test returning the queue as a list literal.'''
        self.assertEqual(list(self.emptyQueue), [])
        li = [1, 3.14, 'foo', True]

        for i in li:
            self.emptyQueue.enqueue(i)

        self.assertEqual(list(self.emptyQueue), li)

    def test_enqueue(self):
        '''Test adding items to the front of the queue.'''
        self.Queue.enqueue(True)
        self.assertEqual(tuple(self.Queue), (0, 1, 2, 3, 4, True))

    def test_dequeue(self):
        '''Test removing items from the front of the queue.'''
        self.assertEqual(self.Queue.dequeue(), 0)
        self.assertEqual(tuple(self.Queue), (1, 2, 3, 4))
        self.assertEqual(self.Queue.dequeue(), 1)
        self.assertEqual(self.Queue.dequeue(), 2)
        self.assertEqual(self.Queue.dequeue(), 3)
        self.assertEqual(self.Queue.dequeue(), 4)
        self.assertEqual(tuple(self.Queue), ())

        with self.assertRaises(ValueError):
            self.Queue.dequeue()

        # test enqueuing after dequeuing
        self.Queue.enqueue(0)
        self.Queue.enqueue(True)
        self.assertEqual(tuple(self.Queue), (0, True))

    def test_peek(self):
        '''Test peeking at the first enqueued item w/o modifying the queue.'''
        self.assertEqual(self.Queue.peek(), 0)

        with self.assertRaises(ValueError):
            self.emptyQueue.peek()
Esempio n. 20
0
from data_structures import Stack, Queue, Deque

stack = Stack()
queue = Queue()
deque = Deque()

print("*** Stack ***")
print(stack)

for i in range(5):
    stack.push(i)
    print(stack)
for i in range(stack.size()):
    stack.pop()
    print(stack)

print("*** Queue ***")
print(queue)

for i in range(5):
    queue.enqueue(i)
    print(queue)
for i in range(queue.size()):
    queue.dequeue()
    print(queue)

print("*** Deque - Stack operation ***")
print(deque)

for i in range(5):
    deque.add_rear(i)
Esempio n. 21
0
 def setUp(self):
     self.structure = Queue()
Esempio n. 22
0
 def setUp(self):
     self.stack = Stack(range(1, 6))
     self.queue = Queue(range(1, 6))
     self.single = SinglyLinkedList()
     self.double = DoublyLinkedList()
     self.btree = BinaryTree()
Esempio n. 23
0
def interleave_stack(stack):
    '''
This problem was asked by Google.

Given a stack of N elements, interleave the first half of the stack with the second half reversed using only one other queue. This should be done in-place.

Recall that you can only push or pop from a stack, and enqueue or dequeue from a queue.

For example, if the stack is [1, 2, 3, 4, 5], it should become [1, 5, 2, 4, 3]. If the stack is [1, 2, 3, 4], it should become [1, 4, 2, 3].
    '''

    stack_size = 0
    queue = Queue()
    while True:
        try:
            queue.enqueue(stack.pop())
            stack_size += 1
        except IndexError:
            break

    while True:
        try:
            stack.push(queue.dequeue())
        except IndexError:
            break

    while True:
        try:
            queue.enqueue(stack.pop())
        except IndexError:
            break

    while True:
        try:
            stack.push(queue.dequeue())
        except IndexError:
            break

    for regurgitation_size in range(stack_size - 1, 0, -1):
        for _ in range(regurgitation_size):
            queue.enqueue(stack.pop())
        for _ in range(regurgitation_size):
            stack.push(queue.dequeue())

    return stack
 def test_blank_queue_object(self):
     q = Queue()
     self.assertEqual(len(q), 0)
Esempio n. 25
0
def test_pop():
    queue, arr = Queue(), []
    assert (queue.is_empty())
    with pytest.raises(AssertionError):
        queue.pop()
    for _ in range(ITERS):
        value = random.randrange(MAX_VAL)
        queue.push(value)
        arr.append(value)
        assert (len(queue) == len(arr))
    for _ in range(ITERS):
        assert (not queue.is_empty())
        expected, arr = arr[0], arr[1:]
        actual = queue.peek()
        assert (actual == expected)
        actual = queue.pop()
        assert (actual == expected)
        assert (len(queue) == len(arr))
    assert (queue.is_empty())
    with pytest.raises(AssertionError):
        queue.pop()
Esempio n. 26
0
def single_bfs(big_list, current):
    queue = Queue()
    explored = Queue()
    newExplored = Stack()
    seen = set()

    pointer = current

    queue.enqueue(pointer)  #Add the our initial position to the
    explored.enqueue(pointer)  #queue
    tra_model = Tra_model()

    while True:

        if queue.isEmpty():
            break
        else:
            pointer = queue.dequeue()
            # First move to the right and check what it is
            pointer = tra_model.move_right(pointer)  #make the first move
            x = pointer[0]
            y = pointer[1]

            if big_list[x][y] == " ":  #if it is space, add its location
                queue.enqueue(pointer)
                explored.enqueue(pointer)
                big_list[x][y] = "#"
                pointer = tra_model.move_left(pointer)
            if big_list[x][y] == "%" or "#":  #if it is hardle, move back
                pointer = tra_model.move_left(pointer)

            if big_list[x][y] == ".":  #if it is goal, add its location
                queue.enqueue(pointer)
                explored.enqueue(pointer)
                break

    # second move to the bottom and check what it is

            pointer = tra_model.move_down(pointer)

            x = pointer[0]
            y = pointer[1]

            if big_list[x][y] == " ":  #if it is space, add its location
                explored.enqueue(pointer)
                queue.enqueue(pointer)
                big_list[x][y] = "#"
                pointer = tra_model.move_up(pointer)
            if big_list[x][y] == "%" or "#":  #if it is hardle, move back
                pointer = tra_model.move_up(pointer)
            if big_list[x][y] == ".":  #if it is goal, add its location
                queue.enqueue(pointer)
                explored.enqueue(pointer)
                break

    # Third move to the left and check what it is

            pointer = tra_model.move_left(pointer)
            x = pointer[0]
            y = pointer[1]

            if big_list[x][y] == " ":  #if it is space, add its location
                explored.enqueue(pointer)
                queue.enqueue(pointer)
                big_list[x][y] = "#"
                pointer = tra_model.move_right(pointer)
            if big_list[x][y] == "%" or "#":  #if it is hardle, move back
                pointer = tra_model.move_right(pointer)
            if big_list[x][y] == ".":  #if it is goal, add its location
                queue.enqueue(pointer)
                explored.enqueue(pointer)
                break

    # Fourth move to the left and check what it is

            pointer = tra_model.move_up(pointer)
            x = pointer[0]
            y = pointer[1]

            if big_list[x][y] == " ":  #if it is space, add its location
                explored.enqueue(pointer)
                queue.enqueue(pointer)
                big_list[x][y] = "#"
                pointer = tra_model.move_down(pointer)
            if big_list[x][y] == "%" or "#":  #if it is hardle, move back
                pointer = tra_model.move_down(pointer)
            if big_list[x][y] == ".":  #if it is goal, add its location
                queue.enqueue(pointer)
                explored.enqueue(pointer)
                break

    expanded = 0
    for i in explored.items:
        expanded += 1

    steps = 0
    for item in explored.items:
        t = tuple(item)
        if t not in seen:
            steps += 1
            newExplored.push(item)
            seen.add(t)

    return newExplored, big_list, steps, expanded
    def __repr__(self):
        level = 0
        q = Queue()
        visit_order = list()
        node = self.get_root()
        q.enqueue( (node,level) )

        while q.size() > 0:
            node, level = q.dequeue()
            if node == None:
                visit_order.append( ("<empty>", level))
                continue
            visit_order.append( (node, level) )
            if node.has_left_child():
                q.enqueue( (node.get_left_child(), level +1 ))
            else:
                q.enqueue( (None, level +1) )

            if node.has_right_child():
                q.enqueue( (node.get_right_child(), level +1 ))
            else:
                q.enqueue( (None, level +1) )

        s = "Tree\n"
        previous_level = -1
        for i in range(len(visit_order)):
            node, level = visit_order[i]
            if level == previous_level:
                s += " | " + str(node)
            else:
                s += "\n" + str(node)
                previous_level = level

        return s
 def test_queue_object(self):
     q = Queue(1)
     self.assertEqual(len(q), 1)
Esempio n. 29
0
class TestDataStructures(unittest.TestCase):

    def setUp(self):
        self.stack = Stack(range(1, 6))
        self.queue = Queue(range(1, 6))
        self.single = SinglyLinkedList()
        self.double = DoublyLinkedList()
        self.btree = BinaryTree()

    # STACK
    def test_stack_push(self):
        self.stack.push(6)
        self.assertEqual(self.stack.stack, range(1, 7)) 

    def test_stack_pop(self):
        self.assertEqual(self.stack.pop(), 5)
        self.assertEqual(self.stack.pop(), 4)

    def test_stack_peek(self):
        self.assertEqual(self.stack.peek(), 5)

    # QUEUE
    def test_queue_push(self):
        self.queue.push(6)
        self.assertEqual(self.queue.queue, range(1, 7))

    def test_queue_pop(self):
        self.assertEqual(self.queue.pop(), 1)
        self.assertEqual(self.queue.pop(), 2)

    def test_queue_peek(self):
        self.assertEqual(self.queue.peek(), 1)
        self.queue.pop()
        self.assertEqual(self.queue.peek(), 2)

    # SINGLY-LINKED LIST
    def test_add_nodes_to_single(self):
        node1, node2, node3 = Node(1), Node(2), Node(3)
        self.single._insert(node1)
        self.single._insert(node2, node1)
        self.assertEqual(self.single.head.value, 1)
        next = self.single.head.next
        self.assertEqual(next, node2)
        self.assertEqual(next.value, 2)
        self.single._insert(node3, node2)
        nextnext = self.single.head.next.next
        self.assertEqual(nextnext, node3)

    def test_add_node_to_beginning_of_single(self):
        node0, node1 = Node(0), Node(1)
        self.single._insert(node1)
        self.single._insert(node0)
        self.assertEqual(self.single.head.value, 0)
        self.assertEqual(self.single.head.next.value, 1)

    def test_remove_nodes_single(self):
        node1, node2, node3, node4 = Node(1), Node(2), Node(3), Node(4)
        self.single._insert(node1)
        self.single._insert(node2, node1)
        self.single._insert(node3, node2)
        self.single._insert(node4, node3)
        self.single._remove(node2)
        self.assertEqual(node2.next, node4)

    def test_remove_node_from_beginning_single(self):
        node1, node2, node3 = Node(1), Node(2), Node(3)
        self.single._insert(node1)
        self.single._insert(node2, node1)
        self.single._insert(node3, node2)
        self.single._remove()
        self.assertEqual(self.single.head, node2)

    def test_single_iteration(self):
        node1, node2, node3, node4 = Node(1), Node(2), Node(3), Node(4)
        self.single._insert(node1)
        self.single._insert(node2, node1)
        self.single._insert(node3, node2)
        self.single._insert(node4, node3)
        self.assertEqual([node for node in self.single], [node1, node2, node3, node4])

    def test_add_node_to_single_for_real(self):
        self.single.insert(2, 0)
        self.assertEqual(self.single[0].value, 2)
        self.single.insert(1, 0)
        self.assertEqual(self.single[0].value, 1)
        self.single.insert(3, 2)
        self.assertEqual(self.single[2].value, 3)
        self.single.insert(4, 100)
        self.assertEqual(self.single[3].value, 4)

    def test_remove_node_from_single_for_real(self):
        for i in range(4, 0, -1):
            self.single.insert(i, 0)
        # [1, 2, 3, 4]
        self.single.remove(1)
        # [1, 3, 4]
        self.assertEqual(self.single[1].value, 3)
        self.single.remove(2)
        # [1, 3]
        self.assertEqual(self.single[0].value, 1)
        self.assertEqual(self.single[1].value, 3)

   # DOUBLE-LINKED LIST
    def test_iteration_double(self):
        node1, node2, node3 = Node(1), Node(2), Node(3)
        node1.next, node2.next, node3.next = node2, node3, None
        node1.prev, node2.prev, node3.prev = None, node1, node2
        self.double.head = node1
        self.double.tail = node3
        # test __iter__
        self.assertEqual([str(i) for i in self.double], [str(i) for i in range(1, 4)])
        # test iterating over reversed
        self.assertEqual([str(i) for i in reversed(self.double)], [str(i) for i in range(3, 0, -1)])

    def test_double_slicing(self):
        node1, node2, node3 = Node(1), Node(2), Node(3)
        node1.next, node2.next, node3.next = node2, node3, None
        node1.prev, node2.prev, node3.prev = None, node1, node2
        self.double.head = node1
        self.double.tail = node3
        self.assertEqual(self.double[0].value, 1)
        self.assertEqual(self.double[1].value, 2)
        self.assertEqual(self.double[2].value, 3)
        self.assertRaises(IndexError, lambda val: self.double[val], 3)

    def test_base_insert_moving_forwards_with_double(self):
        node1, node2, node3 = Node(1), Node(2), Node(3)
        self.double._insert(node1)
        self.assertTrue(test_node(self.double[0], 1, None, None))
        self.assertTrue(test_linked_list(self.double, self.double[0], self.double[0]))

        self.double._insert(node3, node1)
        self.assertTrue(test_node(self.double[0], 1, 3, None))
        self.assertTrue(test_node(self.double[1], 3, None, 1))
        self.assertTrue(test_linked_list(self.double, self.double[0], self.double[1]))

        self.double._insert(node2, node1)
        self.assertTrue(test_node(self.double[0], 1, 2, None))
        self.assertTrue(test_node(self.double[1], 2, 3, 1))
        self.assertTrue(test_node(self.double[2], 3, None, 2))
        self.assertTrue(test_linked_list(self.double, self.double[0], self.double[2]))

        self.assertEqual(str(self.double), str([str(i) for i in range(1, 4)]))

    def test_base_insert_moving_backwards_with_double(self):
        node1, node2, node3 = Node(1), Node(2), Node(3)
        # insert node3 at the beginning/end of the list
        self.double._rev_insert(node3)
        self.assertTrue(test_node(self.double[0], 3, None, None))
        self.assertTrue(test_linked_list(self.double, self.double[0], self.double[0]))
        # insert node one before node 3 ([node1, node3])
        self.double._rev_insert(node1, node3)
        self.assertTrue(test_node(self.double[0], 1, 3, None))
        self.assertTrue(test_node(self.double[1], 3, None, 1))
        self.assertTrue(test_linked_list(self.double, self.double[0], self.double[1]))
        # insert node2 before node3 ([node1, node2, node3])
        self.double._rev_insert(node2, node3)
        self.assertTrue(test_node(self.double[0], 1, 2, None))
        self.assertTrue(test_node(self.double[1], 2, 3, 1))
        self.assertTrue(test_node(self.double[2], 3, None, 2))
        self.assertTrue(test_linked_list(self.double, self.double[0], self.double[2]))
        # check that the array is [node1, node2, node3]
        self.assertEqual(str(self.double), str([str(i) for i in range(1, 4)]))

    def test_insert_at_beginning_of_double(self):
        self.double.insert(2, 0)
        self.assertTrue(test_node(self.double[0], 2, None, None))
        self.assertTrue(test_linked_list(self.double, self.double[0], self.double[0]))
        self.double.insert(1, 0)
        self.assertTrue(test_node(self.double[0], 1, 2, None))
        self.assertTrue(test_node(self.double[1], 2, None, 1))
        self.assertTrue(test_linked_list(self.double, self.double[0], self.double[1]))

    def test_insert_in_middle_and_end_of_double(self):
        self.double.insert(1, 0)
        self.double.insert(3, 1)
        self.assertTrue(test_node(self.double[0], 1, 3, None))
        self.assertTrue(test_node(self.double[1], 3, None, 1))
        self.assertTrue(test_linked_list(self.double, self.double[0], self.double[1]))
        self.double.insert(2, 1) 
        self.assertTrue(test_node(self.double[0], 1, 2, None))
        self.assertTrue(test_node(self.double[1], 2, 3, 1))
        self.assertTrue(test_node(self.double[2], 3, None, 2))
        self.assertTrue(test_linked_list(self.double, self.double[0], self.double[2]))
        self.double.insert(5, 3) 
        self.assertTrue(test_node(self.double[0], 1, 2, None))
        self.assertTrue(test_node(self.double[1], 2, 3, 1))
        self.assertTrue(test_node(self.double[2], 3, 5, 2))
        self.assertTrue(test_node(self.double[3], 5, None, 3))
        self.assertTrue(test_linked_list(self.double, self.double[0], self.double[3]))
        self.double.insert(4, 3) 
        self.assertTrue(test_node(self.double[0], 1, 2, None))
        self.assertTrue(test_node(self.double[1], 2, 3, 1))
        self.assertTrue(test_node(self.double[2], 3, 4, 2))
        self.assertTrue(test_node(self.double[3], 4, 5, 3))
        self.assertTrue(test_node(self.double[4], 5, None, 4))
        self.assertTrue(test_linked_list(self.double, self.double[0], self.double[4]))

    # Binary Tree
    def test_binary_node_equality(self):
        one = BinaryNode(1)
        one2 = BinaryNode(1)
        self.assertTrue(one == one2)
        two = BinaryNode(2)
        self.assertFalse(one == two)

    def test_add_internal_child_to_binary_node(self):
        one = BinaryNode(1)
        two = BinaryNode(2)
        three = BinaryNode(3)
        one.left = three
        # one = {left: 3, right: None}
        one.insert(two, three)
        self.assertTrue(test_binary_node(one, 1, 2, None, None))
        self.assertTrue(test_binary_node(two, 2, 3, None, 1))
        self.assertTrue(test_binary_node(three, 3, None, None, 2))

    def test_add_external_child_to_binary_node(self):
        one = BinaryNode(1)
        two = BinaryNode(2)
        one.insert(two)
        self.assertTrue(test_binary_node(one, 1, 2, None, None))
        self.assertTrue(test_binary_node(two, 2, None, None, 1))
        three = BinaryNode(3)
        one.insert(three)
        self.assertTrue(test_binary_node(one, 1, 2, 3, None))
        self.assertTrue(test_binary_node(two, 2, None, None, 1))
        self.assertTrue(test_binary_node(three, 3, None, None, 1))
        four = BinaryNode(4)
        two.insert(four)
        self.assertTrue(test_binary_node(two, 2, 4, None, 1))
        self.assertTrue(test_binary_node(four, 4, None, None, 2))

    def test_depth_first_generation(self):
        self.btree.root = deep_btree()
        self.assertEquals([int(str(n)) for n in self.btree.depth_gen(self.btree.root)], range(1, 9))

    def test_breadth_first_generation(self):
        self.btree.root = wide_btree()
        self.assertEqual([int(str(n)) for n in self.btree.breadth_gen([self.btree.root])], range(1, 9))

    def test_binary_tree_iteration(self):
        self.btree.root = deep_btree()
        self.assertEquals([int(str(n)) for n in self.btree], range(1, 9))

    def test_contains(self):
        self.btree.root = deep_btree()
        for i in range(1, 9):
            self.assertTrue(i in self.btree)
        self.assertFalse(0 in self.btree)
        self.assertFalse(9 in self.btree)

    def test_insert_into_binary_tree(self):
        ## note - indexing grabs the node with that VALUE, not the node that exists at that index
        #       1
        self.btree.insert(1)
        self.assertTrue(test_binary_node(self.btree[1], 1, None, None, None))
        self.btree.insert(4, 1)
        #       1
        #      /
        #     4
        self.assertTrue(test_binary_node(self.btree[1], 1, 4, None, None))
        self.assertTrue(test_binary_node(self.btree[4], 4, None, None, 1))
        self.btree.insert(3, 1)
        #       1
        #      / \
        #     4   3
        self.assertTrue(test_binary_node(self.btree[1], 1, 4, 3, None))
        self.assertTrue(test_binary_node(self.btree[4], 4, None, None, 1))
        self.assertTrue(test_binary_node(self.btree[3], 3, None, None, 1))
        self.btree.insert(2, 1, 4)
        #       1
        #      / \
        #     2   3
        #    /
        #   4
        self.assertTrue(test_binary_node(self.btree[1], 1, 2, 3, None))
        self.assertTrue(test_binary_node(self.btree[2], 2, 4, None, 1))
        self.assertTrue(test_binary_node(self.btree[3], 3, None, None, 1))
        self.assertTrue(test_binary_node(self.btree[4], 4, None, None, 2))


    # Binary Search Tree
    def test_binary_search_node(self):
        root = binary_search_tree()
        for i in range(1, 9):
            self.assertTrue(root.search(i))
        self.assertFalse(root.search(0))
        self.assertFalse(root.search(9))

    def test_binary_search_insert(self):
    #               5
    #             /    \
    #           3        8
    #         /  \     /
    #       2     4   6

        root = BinarySearchNode(5)
        self.assertTrue(test_binary_node(root, 5, None, None, None))
        root.insert(3)
        self.assertTrue(test_binary_node(root, 5, 3, None, None))
        self.assertTrue(test_binary_node(root[3], 3, None, None, 5))
        root.insert(8)
        self.assertTrue(test_binary_node(root, 5, 3, 8, None))
        self.assertTrue(test_binary_node(root[3], 3, None, None, 5))
        self.assertTrue(test_binary_node(root[8], 8, None, None, 5))
        root.insert(4)
        self.assertTrue(test_binary_node(root, 5, 3, 8, None))
        self.assertTrue(test_binary_node(root[3], 3, None, 4, 5))
        self.assertTrue(test_binary_node(root[8], 8, None, None, 5))
        self.assertTrue(test_binary_node(root[4], 4, None, None, 3))
        root.insert(2)
        self.assertTrue(test_binary_node(root, 5, 3, 8, None))
        self.assertTrue(test_binary_node(root[3], 3, 2, 4, 5))
        self.assertTrue(test_binary_node(root[8], 8, None, None, 5))
        self.assertTrue(test_binary_node(root[2], 2, None, None, 3))
        self.assertTrue(test_binary_node(root[4], 4, None, None, 3))
        root.insert(6)
        self.assertTrue(test_binary_node(root, 5, 3, 8, None))
        self.assertTrue(test_binary_node(root[3], 3, 2, 4, 5))
        self.assertTrue(test_binary_node(root[8], 8, 6, None, 5))
        self.assertTrue(test_binary_node(root[2], 2, None, None, 3))
        self.assertTrue(test_binary_node(root[4], 4, None, None, 3))
        self.assertTrue(test_binary_node(root[6], 6, None, None, 8))

    # def test_binary_search_remove_external_node(self):
    #     root = binary_search_tree()
    #     root.remove(1)
    #     self.assertTrue(test_binary_node(root, 5, 3, 8, None))
    #     self.assertTrue(test_binary_node(root[3], 3, 2, 4, 5))
    #     self.assertTrue(test_binary_node(root[8], 8, 6, None, 5))
    #     self.assertTrue(test_binary_node(root[2], 2, None, None, 3))
    #     self.assertTrue(test_binary_node(root[4], 4, None, None, 3))
    #     self.assertTrue(test_binary_node(root[6], 6, None, 7, 8))
    #     self.assertTrue(test_binary_node(root[7], 7, None, None, 6))
    #     self.assertFalse(1 in root)
    #     self.assertFalse(root.search(1))

    def test_binary_search_remove_internal_node_without_children(self):
        root = binary_search_tree()
        root.remove(3, root[4])
        self.assertTrue(test_binary_node(root, 5, 4, 8, None))
        self.assertTrue(test_binary_node(root[4], 4, 2, None, 5))
        self.assertTrue(test_binary_node(root[8], 8, 6, None, 5))
        self.assertTrue(test_binary_node(root[2], 2, 1, None, 4))
        self.assertTrue(test_binary_node(root[6], 6, None, 7, 8))
        self.assertTrue(test_binary_node(root[7], 7, None, None, 6))
        self.assertFalse(3 in root)

    def test_binary_search_remove_internal_node_with_children1(self):
        root = binary_search_tree()
        root.insert(3.5)
        root.insert(4.5)
        root.remove(3, root[4])

        self.assertTrue(test_binary_node(root, 5, 4, 8, None))
        self.assertTrue(test_binary_node(root[4], 4, 3.5, 4.5, 5))
        self.assertTrue(test_binary_node(root[8], 8, 6, None, 5))
        self.assertTrue(test_binary_node(root[2], 2, 1, None, 3.5))
        self.assertTrue(test_binary_node(root[6], 6, None, 7, 8))
        self.assertTrue(test_binary_node(root[1], 1, None, None, 2))
        self.assertTrue(test_binary_node(root[3.5], 3.5, 2, None, 4))
        self.assertTrue(test_binary_node(root[4.5], 4.5, None, None, 4))
        self.assertTrue(test_binary_node(root[7], 7, None, None, 6))
        self.assertFalse(3 in root)

    def test_binary_search_remove_internal_node_with_children2(self):
        root = binary_search_tree()
        root.insert(3.5)
        root.insert(4.5)
        root.remove(3, root[2])

        self.assertTrue(test_binary_node(root, 5, 2, 8, None))
        self.assertTrue(test_binary_node(root[2], 2, 1, 4, 5))
        self.assertTrue(test_binary_node(root[8], 8, 6, None, 5))
        self.assertTrue(test_binary_node(root[6], 6, None, 7, 8))
        self.assertTrue(test_binary_node(root[1], 1, None, None, 2))
        self.assertTrue(test_binary_node(root[4], 4, 3.5, 4.5, 2))
        self.assertTrue(test_binary_node(root[3.5], 3.5, None, None, 4))
        self.assertTrue(test_binary_node(root[4.5], 4.5, None, None, 4))
        self.assertTrue(test_binary_node(root[7], 7, None, None, 6))
        self.assertFalse(3 in root)

    # HEAP
    def test_heap_iteration(self):
        heap = Heap(max_heap())
        self.assertEqual([int(str(n)) for n in heap.breadth()], [17, 15, 10, 6, 10, 7])
        self.assertEqual([int(str(n)) for n in heap], [17, 15, 10, 6, 10, 7])
        self.assertEqual(heap.flatten(), [17, 15, 10, 6, 10, 7])

    def test_find_open_with_empty_aunt(self):
        node17 = HeapNode(17)
        node15 = HeapNode(15)
        node11 = HeapNode(11)
        node6 = HeapNode(6)
        node10 = HeapNode(10)
        node17.left = node15
        node17.right = node11
        node15.left = node6
        node15.right = HeapNode(10)

        heap = Heap(node17)
        self.assertEqual(heap[-1].value, 10)
        self.assertEqual(heap.find_open(), (node11, 'left'))

    def test_find_open_with_single_child_aunt(self):
        node17 = HeapNode(17)
        node15 = HeapNode(15)
        node11 = HeapNode(11)
        node6 = HeapNode(6)
        node10 = HeapNode(10)
        node7 = HeapNode(7)
        node17.left = node15
        node17.right = node11
        node15.left = node6
        node15.right = HeapNode(10)
        node11.left = node7

        heap = Heap(node17)
        self.assertEqual(heap[-1].value, 7)
        self.assertEqual(heap.find_open(), (node11, 'right'))

    def test_find_open_with_non_empty_aunt(self):
        node17 = HeapNode(17)
        node15 = HeapNode(15)
        node11 = HeapNode(11)
        node6 = HeapNode(6)
        node10 = HeapNode(10)
        node7 = HeapNode(7)
        node5 = HeapNode(5)
        node17.left = node15
        node17.right = node11
        node15.left = node6
        node15.right = HeapNode(10)
        node11.left = node7
        node11.right = node5
        
        heap = Heap(node17)
        self.assertEqual(heap[-1].value, 5)
        self.assertEqual(heap.find_open(), (node6, 'left'))

    def test_insert(self):
        node17 = HeapNode(17)
        heap = Heap(node17)
        heap.insert(15)
        self.assertTrue(test_binary_node(heap.root, 17, 15, None, None))
        self.assertTrue(test_binary_node(heap.root.left, 15, None, None, 17))
        heap.insert(10)
        self.assertTrue(test_binary_node(heap.root, 17, 15, 10, None))
        self.assertTrue(test_binary_node(heap.root.left, 15, None, None, 17))        
        self.assertTrue(test_binary_node(heap.root.right, 10, None, None, 17))
        heap.insert(6)
        self.assertTrue(test_binary_node(heap.root, 17, 15, 10, None))
        self.assertTrue(test_binary_node(heap.root.left, 15, 6, None, 17))        
        self.assertTrue(test_binary_node(heap.root.right, 10, None, None, 17))
        self.assertTrue(test_binary_node(heap.root.left.left, 6, None, None, 15))
        heap.insert(10)
        self.assertTrue(test_binary_node(heap.root, 17, 15, 10, None))
        self.assertTrue(test_binary_node(heap.root.left, 15, 6, 10, 17))        
        self.assertTrue(test_binary_node(heap.root.right, 10, None, None, 17))
        self.assertTrue(test_binary_node(heap.root.left.left, 6, None, None, 15))
        self.assertTrue(test_binary_node(heap.root.left.right, 10, None, None, 15))
        heap.insert(7)
        self.assertTrue(test_binary_node(heap.root, 17, 15, 10, None))
        self.assertTrue(test_binary_node(heap.root.left, 15, 6, 10, 17))        
        self.assertTrue(test_binary_node(heap.root.right, 10, 7, None, 17))
        self.assertTrue(test_binary_node(heap.root.left.left, 6, None, None, 15))
        self.assertTrue(test_binary_node(heap.root.left.right, 10, None, None, 15))
        self.assertTrue(test_binary_node(heap.root.right.left, 7, None, None, 10))

    def test_bubble(self):

        #               17                      17                  100
        #             /    \                  /    \               /    \
        #          15        10    -->     15       100    -->   15       17
        #         /  \      /  \          /  \      /  \        /  \     /  \
        #       6     10   7   100      6     10   7   10     6     10  7   10

        heap = Heap(max_heap())
        parent = heap.root.right
        last = HeapNode(100)
        parent.right = last
        last.parent = parent
        heap.bubble(last)

        self.assertTrue(test_binary_node(heap.root, 100, 15, 17, None))
        self.assertTrue(test_binary_node(heap.root.right, 17, 7, 10, 100))
        self.assertTrue(test_binary_node(heap.root.right.left, 7, None, None, 17))
        self.assertTrue(test_binary_node(heap.root.right.right, 10, None, None, 17))

        #             100                  100                  100
        #            /    \               /    \               /    \
        #          15       17   -->    15       17    -->  99       17
        #         /  \     /  \        /  \     /  \        /  \     /  \
        #       6     10  7   10     99   10  7   10     15     10  7   10
        #      /                     /                   /
        #     99                   6                   6

        parent = heap.root.left.left
        last = HeapNode(99)
        last.parent = parent
        parent.left = last
        heap.bubble(last)
        self.assertTrue(test_binary_node(heap.root, 100, 99, 17, None))
        self.assertTrue(test_binary_node(heap.root.left, 99, 15, 10, 100))
        self.assertTrue(test_binary_node(heap.root.left.left, 15, 6, None, 99))
        self.assertTrue(test_binary_node(heap.root.left.right, 10, None, None, 99))
        self.assertTrue(test_binary_node(heap.root.left.left.left, 6, None, None, 15))

        #             100                  100                  100
        #            /    \               /    \               /    \
        #          99       17   -->    99       17    -->  100       17
        #         /  \     /  \        /  \     /  \        /  \      /  \
        #       15    10  7   10     15  100  7   10     15    99   7   10
        #      /  \   /             / \   /              /  \   /
        #     6   12 100          6  12 10             6   12 10

        fifteen = heap.root.left.left
        twelve = HeapNode(12)
        twelve.parent = fifteen
        fifteen.right = twelve

        ten = heap.root.left.right
        last = HeapNode(100)
        ten.left = last
        last.parent = ten
        heap.bubble(last)
        self.assertTrue(test_binary_node(heap.root, 100, 100, 17, None))
        self.assertTrue(test_binary_node(heap.root.left, 100, 15, 99, 100))
        self.assertTrue(test_binary_node(heap.root.left.left, 15, 6, 12, 100))
        self.assertTrue(test_binary_node(heap.root.left.right, 99, 10, None, 100))


    def test_insertion_with_percolation(self):
        #               17
        #             /    \
        #          15        10
        #         /  \      /
        #       6     10   7

        #     6
        six = HeapNode(6)
        heap = Heap(six)
        self.assertTrue(test_binary_node(heap.root, 6, None, None, None))

        #     6             10
        #    /    -->     /
        #  10           6
        heap.insert(10)
        self.assertTrue(test_binary_node(heap.root, 10, 6, None, None))
        self.assertTrue(test_binary_node(heap.root.left, 6, None, None, 10))          
        #     10             10
        #    /  \  -->     /   \
        #  6     7       6      7
        heap.insert(7)
        self.assertTrue(test_binary_node(heap.root, 10, 6, 7, None))
        self.assertTrue(test_binary_node(heap.root.left, 6, None, None, 10)) 
        self.assertTrue(test_binary_node(heap.root.right, 7, None, None, 10))
        #      10            15
        #     /  \  -->     /   \
        #   6     7       10      7
        #  /              / 
        # 15             6
        heap.insert(15)
        self.assertTrue(test_binary_node(heap.root, 15, 10, 7, None))
        self.assertTrue(test_binary_node(heap.root.left, 10, 6, None, 15)) 
        self.assertTrue(test_binary_node(heap.root.right, 7, None, None, 15))
        self.assertTrue(test_binary_node(heap.root.left.left, 6, None, None, 10))
        #      15            17
        #     /  \  -->     /   \
        #   10    7       15      7
        #  /  \          /  \
        # 6    17       6    10
        heap.insert(17)
        self.assertTrue(test_binary_node(heap.root, 17, 15, 7, None))
        self.assertTrue(test_binary_node(heap.root.left, 15, 6, 10, 17)) 
        self.assertTrue(test_binary_node(heap.root.right, 7, None, None, 17))
        self.assertTrue(test_binary_node(heap.root.left.left, 6, None, None, 15))
        self.assertTrue(test_binary_node(heap.root.left.right, 10, None, None, 15))
        #       17             17    
        #      /   \  -->     /   \   
        #    15     7       15     11
        #   /  \   /       /  \   /  
        #  6   10 11      6   10 7  
        heap.insert(11)
        self.assertTrue(test_binary_node(heap.root, 17, 15, 11, None))
        self.assertTrue(test_binary_node(heap.root.left, 15, 6, 10, 17)) 
        self.assertTrue(test_binary_node(heap.root.right, 11, 7, None, 17))
        self.assertTrue(test_binary_node(heap.root.left.left, 6, None, None, 15))
        self.assertTrue(test_binary_node(heap.root.left.right, 10, None, None, 15))
        self.assertTrue(test_binary_node(heap.root.right.left, 7, None, None, 11))

    def test_build_from_array(self):
        heap1 = [17, 15, 11, 6, 10, 7]
        heap2 = [6, 10, 7, 15, 17, 11]
        heap = Heap(array=heap1)
        self.assertTrue(test_binary_node(heap.root, 17, 15, 11, None))
        self.assertTrue(test_binary_node(heap.root.left, 15, 6, 10, 17)) 
        self.assertTrue(test_binary_node(heap.root.right, 11, 7, None, 17))
        self.assertTrue(test_binary_node(heap.root.left.left, 6, None, None, 15))
        self.assertTrue(test_binary_node(heap.root.left.right, 10, None, None, 15))
        self.assertTrue(test_binary_node(heap.root.right.left, 7, None, None, 11)) 
        heap = Heap(array=heap2)
        self.assertTrue(test_binary_node(heap.root, 17, 15, 11, None))
        self.assertTrue(test_binary_node(heap.root.left, 15, 6, 10, 17)) 
        self.assertTrue(test_binary_node(heap.root.right, 11, 7, None, 17))
        self.assertTrue(test_binary_node(heap.root.left.left, 6, None, None, 15))
        self.assertTrue(test_binary_node(heap.root.left.right, 10, None, None, 15))
        self.assertTrue(test_binary_node(heap.root.right.left, 7, None, None, 11)) 

    def test_delete(self):

        #          17                  7                  15                  15          
        #        /    \              /    \              /    \              /    \    
        #     15        11  -->   15        11  -->   7        11   -->   10        11
        #    /  \      /         /  \                /  \                /  \        
        #  6     10   7        6     10            6     10            6     7       
        heap = Heap(max_heap())
        heap[2].value = 11
        heap.delete_root()
        self.assertTrue(test_binary_node(heap.root, 15, 10, 11, None))
        self.assertTrue(test_binary_node(heap.root.left, 10, 6, 7, 15)) 
        self.assertTrue(test_binary_node(heap.root.right, 11, None, None, 15))
        self.assertTrue(test_binary_node(heap.root.left.left, 6, None, None, 10))
        self.assertTrue(test_binary_node(heap.root.left.right, 7, None, None, 10))
        #         15                  7                  11    
        #       /    \              /    \             /    \  
        #     10      11  -->    10       11  -->   10       7
        #    /  \               /                  /           
        #  6     7            6                  6             
        heap.delete_root()
        self.assertTrue(test_binary_node(heap.root, 11, 10, 7, None))
        self.assertTrue(test_binary_node(heap.root.left, 10, 6, None, 11)) 
        self.assertTrue(test_binary_node(heap.root.right, 7, None, None, 11))
        self.assertTrue(test_binary_node(heap.root.left.left, 6, None, None, 10))
        #          11               6                 10           
        #        /    \           /    \            /    \        
        #     10       7  -->   10      7   -->   6       7
        #    /                                                      
        #  6                                                       
        heap.delete_root()
        self.assertTrue(test_binary_node(heap.root, 10, 6, 7, None))
        self.assertTrue(test_binary_node(heap.root.left, 6, None, None, 10)) 
        self.assertTrue(test_binary_node(heap.root.right, 7, None, None, 10))
        #      10             7        
        #    /    \  -->    /       
        #  6       7      6     
        heap.delete_root()
        self.assertTrue(test_binary_node(heap.root, 7, 6, None, None))
        self.assertTrue(test_binary_node(heap.root.left, 6, None, None, 7)) 
        #      7                
        #    /   -->   6
        #  6             
        heap.delete_root()
        self.assertTrue(test_binary_node(heap.root, 6, None, None, None))
        #   6   -->  None
        heap.delete_root()
        self.assertFalse(heap.root)
Esempio n. 30
0
def hot_potato(names_lst, num):
    """     
     queue data structure implementation
     returns the last person surviving in the queue
     """
    
    names = Queue()
    
    for i in names_lst:
        # add the names to the queue
        names.add(i)
    
    turns = 1
    while names.get_length() > 1:
        
        if turns < num:
            # get and return items to queue
            potato = names.get()
            names.add(potato)
            turns += 1
            
        else:
            # when turns == num remove item
            names.get()
            turns = 1
    
    # get the survivor off of the queue
    return names.get()       
    def test_dequeue(self):
        q = Queue(1)
        q.enqueue(2)
        q.enqueue(3)
        q.enqueue(4)

        self.assertEqual(len(q), 4)
        self.assertEqual(q.peek(), 1)
        q.dequeue()
        self.assertEqual(len(q), 3)
        self.assertEqual(q.peek(), 2)

        while q.storage:
            q.dequeue()

        self.assertRaises(IndexError, q.dequeue)
Esempio n. 32
0
def single_dfs(big_list, current):
    stack = Stack()
    explored = Queue()
    pointer = current

    stack.push(pointer)
    explored.enqueue(pointer)
    tra_model = Tra_model()

    while True:

        if stack.isEmpty():
            break
        else:
            pointer = stack.peek()

        x = pointer[0]
        y = pointer[1]
        if big_list[x][y + 1] == " ":  #if right is empty
            pointer = tra_model.move_right(pointer)
            stack.push(pointer)
            explored.enqueue(pointer)
            x = pointer[0]
            y = pointer[1]
            big_list[x][y] = "#"
            continue  #return to the top of the loop

        if big_list[x][y + 1] == ".":
            pointer = tra_model.move_right(pointer)
            stack.push(pointer)
            explored.enqueue(pointer)
            break

        if big_list[x][y + 1] == "%" or "#":  #if right is wall
            if big_list[x + 1][y] == " ":  #if down is empty
                pointer = tra_model.move_down(pointer)
                stack.push(pointer)
                explored.enqueue(pointer)
                x = pointer[0]
                y = pointer[1]
                big_list[x][y] = "#"
                continue

            if big_list[x + 1][y] == ".":
                pointer = tra_model.move_down(pointer)
                stack.push(pointer)
                explored.enqueue(pointer)
                break

            if big_list[x + 1][y] == "%" or "#":  # if down is wall
                if big_list[x - 1][y] == " ":  # if up is empty

                    pointer = tra_model.move_up(pointer)
                    stack.push(pointer)
                    explored.enqueue(pointer)
                    x = pointer[0]
                    y = pointer[1]
                    big_list[x][y] = "#"
                    continue  # return to the top of the loop

                if big_list[x - 1][y] == ".":
                    pointer = tra_model.move_up(pointer)
                    stack.push(pointer)
                    explored.enqueue(pointer)
                    break

                if big_list[x - 1][y] == "%" or "#":  #if up is wall
                    if big_list[x][y - 1] == " ":  #if left is empty
                        pointer = tra_model.move_left(pointer)
                        stack.push(pointer)
                        explored.enqueue(pointer)
                        x = pointer[0]
                        y = pointer[1]
                        big_list[x][y] = "#"
                        continue  #return to the top

                    if big_list[x - 1][y] == ".":
                        pointer = tra_model.move_left(pointer)
                        stack.push(pointer)
                        explored.enqueue(pointer)
                        break
                    if big_list[x][y - 1] == "%" or "#":
                        big_list[x][y] = "*"
                        stack.pop()

    expanded = 0
    for i in explored.items:
        expanded += 1
        x = i[0]
        y = i[1]

        if big_list[x][y] == "*":
            big_list[x][y] = " "

    steps = 0
    for i in explored.items:
        x = i[0]
        y = i[1]

        if big_list[x][y] == "#":
            steps += 1

    return explored, big_list, steps, expanded