def parseTree(expression): tokens = expression.split() tree_holder = Stack() main_tree = BinaryTree('') tree_holder.push(main_tree) currentTree = main_tree for val in tokens: if val == '(': currentTree.add_left('') tree_holder.push(currentTree) currentTree = currentTree.get_left() elif val not in '+-*/': currentTree.set_root_val(val) parent = tree_holder.pop() currentTree = parent elif val in '+-*/': currentTree.set_root_val(val) currentTree.add_right('') tree_holder.push(currentTree) currentTree = currentTree.get_right() elif val == ')': currentTree = tree_holder.pop() else: raise ValueError return main_tree
def randomize(maze): stack = Stack() current = maze.board[0][0] visited_count = 0 while True: q = current.get_random_nbr() if not current.visited: visited_count += 1 current.visited = True if q is None: if stack.size > 0: current = stack.pop() else: raise StopIteration() else: next, x = q stack.push(current) current.unlock(x) next.unlock((x + 2) % 4) current = next if visited_count >= maze.length * maze.height: raise StopIteration() yield current
def insert_node(self, node): lessFreq_stack = Stack() while self.stack.num_elements>0 and self.stack.top().get_freq() < node.get_freq(): lessFreq_stack.push(self.stack.pop()) self.stack.push(node) while lessFreq_stack.num_elements>0: self.stack.push(lessFreq_stack.pop())
class TowersOfHanoi(object): """ Towers of Hanoi """ def __init__(self, num_discs=3, verbose=True): self.tower_1 = Stack() self.tower_2 = Stack() self.tower_3 = Stack() self.num_discs = num_discs self.verbose = verbose # Initialize tower for disc in range(self.num_discs, 0, -1): self.tower_1.push(disc) # Counter for number of recursive calls needed to solve self._num_steps = 0 def __repr__(self): out = '' for i in range(self.num_discs): for tower in self.towers: if len(tower) <= i: out += "|" else: out += str(tower[i]) out += "\t" out += "\n" # Flip UD return "\n".join(out.split("\n")[::-1]) @property def towers(self): return (self.tower_1, self.tower_2, self.tower_3) def _step(self, begin, end, temp, disc): """ Recursive solution to towers of Hanoi. If verbose is True, print out state of towers at every step """ if disc == 1: end.push(begin.pop()) else: self._step(begin, temp, end, disc - 1) self._step(begin, end, temp, 1) self._step(temp, end, begin, disc - 1) self._num_steps += 1 if self.verbose: print("Step %i:" %(self._num_steps)) print(self) def solve(self): """ Kick-off recursive solution chain. """ self._step(self.tower_1, self.tower_3, self.tower_2, self.num_discs)
def __init__(self, num_discs=3, verbose=True): self.tower_1 = Stack() self.tower_2 = Stack() self.tower_3 = Stack() self.num_discs = num_discs self.verbose = verbose # Initialize tower for disc in range(self.num_discs, 0, -1): self.tower_1.push(disc) # Counter for number of recursive calls needed to solve self._num_steps = 0
def traverse_df_po_generator(self, root=None): #deep-first tree traversing if root is None : root = self.root stack = Stack.Stack([root]) ; register = Stack.Stack([len(root.nodes)]) while register.top() : register.decr() ; node = root.nodes[register.top()] ; register.push(len(node.nodes)) while node != root : if register.top() : register.decr() ; stack.push(node) node = node.nodes[register.top()] ; register.push(len(node.nodes)) else : yield node ; node = stack.pop() ; register.dlt() yield root
def evaluate_postfix(expr): if len(expr) == 0: return "Expression is invalid" nums = Stack() for char in expr: if char in "+*-": num1 = nums.pop() num2 = nums.pop() if char == "+": subtotal = num1 + num2 elif char == "*": subtotal = num1 * num2 elif char == "-": subtotal = num2 - num1 nums.push(subtotal) else: nums.push(int(char)) if len(nums._items) > 1: return "Expression is invalid" return nums.pop()
def dft(self, starting_vertex_id): """ Traverse and print each vertex in depth-first order (DFT) beginning from starting_vertex. """ # Initialize empty stack and set of visited nodes: stack = Stack() visited = set() # Check if provided starting vertex is in our graph: if starting_vertex_id in self.vertices.keys(): # If so, add starting vertex to stack: stack.push(starting_vertex_id) else: return IndexError( f"Provided starting vertex {starting_vertex_id} does not exist in graph!" ) # Process all vertices via BFT: while stack.size() > 0: # Get next vertex to process as first item in stack: current_vertex = stack.pop() # If the current vertex has not already been visited+processed, process it: if current_vertex not in visited: # Process current vertex: print(current_vertex) # Add adjacent vertices to stack for future processing: for adjacent_vertex in self.get_neighbors(current_vertex): stack.push(adjacent_vertex) # Mark current vertex as "visited" by adding to our set of visited vertices: visited.add(current_vertex)
def sort_frequencies(self): freq_dict ={i:0 for i in set(self.data)} for i in self.data: freq_dict[i]+=1 sorted_freq = sorted(freq_dict.items(), #Sort: more frequent first key=lambda x: (x[1],x[0]), reverse=True) stack = Stack() #Push most frequent firts [stack.push(Node(freq = x[1], char= x[0])) for x in sorted_freq] #print(stack.arr) #print('top stack:', stack.top()) return stack
def buildParseTree(fpexp): exp_list = fpexp.split() # split the expression in a list wth the delimateur being space stack = Stack() current_node = BinaryTree('') tokens = ['+', '-', '/', '*'] #stack.push(current_node) for char in exp: if char == '(': current_node.insertLeft('') S.push(current_node) # push parent into the stack current_node = current_node.leftChild elif char.isdigit(): current_node.key = int(char) current_node = S.pop() elif char in tokens: current_node.insertRight('') current_node.key = char S.push(current_node) current_node = current_node.rightChild elif char == ')': current_node = S.pop() else: raise ValueError
def revstring(mystr): """ :type mystr: string :rtype: string use Stack Last In First Out feature to reverse a string """ aStack = Stack() for i in list(mystr): aStack.push(i) revstr = "" while not aStack.isEmpty(): revstr += aStack.pop() return revstr
def get_digits(self): """ This pushes numbers in stack. Then it converts that stack into a dictionary value with an alphabetic key. The reason we do this is that the calculations function cannot handle multiple digits because it is processing each element by character. For example, 2 + 2 can be processed but 10 + 10 cannot because it would be expecting a + - * / operator between the 1 and the 0. It is easier to have proxy variables, such as A + B rather than 10 + 10, and use that to pull dictionary values. The result would look like self.numbers.get('A') + self.numbers.get('B') with the self.numbers dictionary looking like {'A': 10, 'B': 10}. The calculator would read this as 10 + 10 without issue. Thus, the purpose of this function is to build that self.numbers dictionary and build self.final_infix with alphabetical variables substituting multi-digit numbers. self.final_infix is a word that looks like 'A+B'. """ operands = Stack() alphabet_num = 65 for char in self.infix_split: if char in '0123456789.': operands.push(char) elif not operands.isempty(): alphabet = chr(alphabet_num) alphabet_num += 1 number = '' # Converts number into a dictionary item. while not operands.isempty(): number = operands.pop() + number self.numbers[alphabet] = number self.final_infix += alphabet + char else: self.final_infix += char
def dfs(self): self.clear() self._display_grid() # frontier is where we've yet to go frontier: Stack[Node[T]] = Stack() frontier.push(Node(self.start, None)) # explored is where we've been explored: Set[T] = {self.start} self.step(frontier, explored, None)
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 test_stack(): stack = Stack() stack.push(3) stack.push(2) assert stack.peek() == 2 assert stack.pop() == 2 assert stack.pop() == 3 assert stack.is_empty()
def test_pop(self): """ Test Case to test the pop operation """ stack = Stack() stack.push(1) num = stack.pop() self.assertEqual(num, 1) stack.push(2) stack.push(3) num = stack.pop() self.assertEqual(num, 3)
def test_dfs_assert_equal_return_lists(self): visited_list, path_list = dfs(self.grid, self.start, self.end, _stack=Stack()) self.assertEqual( visited_list, self.dfs_correct_returns["visited_list"], "tested visited_list is not equal to correct visited list") self.assertEqual(path_list, self.dfs_correct_returns["path_list"], "tested path_list is not equal to correct path list")
def execute_df(self, root=None, exec_pr=Tree._func_pass, exec_in=Tree._func_pass, exec_po=Tree._func_pass, **kwargs): #deep-first tree traversing if root is None : root = self.root exec_pr(root, **kwargs) #pre-order call stack = Stack.Stack([root]) ; register = Stack.Stack([len(root.nodes)]) if not len(root.nodes) : exec_in(root, **kwargs) #in-order call while register.top() : if register.top() == len(root.nodes) - 1 : exec_in(root, **kwargs) #in-order call register.decr() ; node = root.nodes[register.top()] ; register.push(len(node.nodes)) exec_pr(node, **kwargs) #pre-order call while node != root : if not len(node.nodes) or register.top() == len(node.nodes) - 1 : exec_in(node, **kwargs) #in-order call if register.top() : register.decr() ; stack.push(node) ; node = node.nodes[register.top()] ; register.push(len(node.nodes)) else : exec_po(node, **kwargs) #post-order call node = stack.pop() ; register.dlt() exec_po(root, **kwargs) #post-order call
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 test_pop_on_empty_stack(self): """ Test Case to test pop operation on Empty Stack """ stack = Stack() stack.push(1) stack.pop() self.assertEqual(stack.length, 0, STACK_SIZE_ZERO_MSG) # Stack should be empty after one push and one pop operation # Should raise EmptyStackException on pop() with self.assertRaises(exceptions.EmptyStackException): stack.pop()
def test_size(self): """ Test Case to check the size of the stack after push and pop operations """ stack = Stack() self.assertEqual(stack.length, 0, STACK_SIZE_ZERO_MSG) stack.push(1) self.assertEqual(stack.length, 1, INCORRECT_STACK_SIZE_MSG) stack.push(2) stack.push(3) self.assertEqual(stack.length, 3, INCORRECT_STACK_SIZE_MSG) stack.pop() self.assertEqual(stack.length, 2, INCORRECT_STACK_SIZE_MSG)
def postfixEval(postfixExpr): operandStack = Stack() tokenList = postfixExpr.split() for token in tokenList: if token.isdigit(): operandStack.push(int(token)) else: operand2 = operandStack.pop() operand1 = operandStack.pop() result = doMath(token, operand1, operand2) operandStack.push(result) return operandStack.pop()
def test_push(): stack, arr = Stack(), [] assert(stack.is_empty()) for expected in range(ITERS): stack.push(expected) arr = [expected] + arr actual = stack.peek() assert(len(stack) == len(arr)) assert(expected == actual) assert(not stack.is_empty())
def dfs(graph: Graph, start_node: str, target_node: str, visited_nodes: set): stack = Stack() stack.push(start_node) while not stack.is_empty(): current = stack.pop() if current == target_node: return True adj = graph.get_edges_node(current) for node in adj: if node not in visited_nodes: stack.push(node) return False
def parChecker(symbolString): ''' in: a string containing all symbols return: boolean, true for balaced, vice versa Completed extended parenthesis checker for: [,{,(,),},] ''' leftPar = Stack() strList = list(symbolString) balanced = True symbol = {'[':']','{':'}','(':')'} i = 0 while i < len(symbolString) and balanced: if strList[i] in ['[','(','{']: leftPar.push(strList[i]) else: if leftPar.isEmpty(): balanced = False else: if not strList[i] == symbol[leftPar.pop()]: balanced = False i += 1 if not leftPar.isEmpty(): balanced = False return balanced
def baseConverter(decNumber,base): ''' decNumber: decimal number base: int between 2 and 16 Algorithm for binary conversion can easily be extended to perform the conversion for any base. In computer science it is common to use a number of different encodings. The most common of these are binary, octal (base 8) , and hexadecimal (base 16). ''' baseNumber = '' reminders = Stack() while decNumber > 0: reminders.push(decNumber%base) decNumber = decNumber//base while not reminders.isEmpty(): baseNumber += str(reminders.pop()) return baseNumber
def attempt_2(self, head: ListNode, k: int) -> ListNode: """ Better solution: Insert all elements into a stack and pop k elements. The last popped is returned. Don't need to know the length of the list in this algorithm. :param head: head of list :param k: parameter, k :return: returns the k'th to last element :Time: O(N) :Space: O(N) """ stack = Stack() curr = head while curr is not None: stack.push(curr) curr = curr.next ret_val = None for i in range(k): popped = stack.pop() if i == k - 1: ret_val = popped return ret_val
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()
def test_push(self): """ Test Case to test the push operation """ stack = Stack() stack.push(1) self.assertEqual(stack.top, 1) stack.push(2) stack.push(3) self.assertEqual(stack.top, 3)
def paranthesis_checker(string): stack = Stack() balanced = True index = 0 while index < len(string) and balanced: symbol = string[index] if symbol == '(': stack.push(symbol) else: if stack.isEmpty(): balanced = False else: stack.pop() index = index + 1 if balanced and stack.isEmpty(): return True else: return False
def HexToBinary(number): bin_holder = Stack() while number > 0: rem = number % 2 bin_holder.push(rem) number = number // 2 bin_string = "" while not bin_holder.isEmpty(): bin_string = bin_string + str(bin_holder.pop()) return bin_string
def check_balanced_symbols(symbols_string): """Checks if opening and closing symbols in a string are balanced""" open_symbols = Stack() for symbol in symbols_string: if symbol in "({[": open_symbols.push(symbol) elif symbol in ")}]": if open_symbols.is_empty(): return False open_symbol = open_symbols.pop() if not is_matching_symbols(open_symbol, symbol): return False return open_symbols.is_empty()
def external_call( self, # account_number:int, exec_env: ExecutionEnvironment, condition=True #machine_state:MachineState=None ): # print('external call') # print('prev storage:') # print(self.get_processing_block().get_machine_state().get_storage().get_data()) continuation_block = self.processing_block.inherit( len(self.basic_blocks), False) self.add_basic_block(continuation_block) # self.push_to_call_stack(continuation_block) new_block_number = len(self.basic_blocks) external_block = self.processing_block.duplicate( # account_number=account_number, new_block_number=new_block_number, exec_env=exec_env, # dfs_stack=[] ) # print('external call') # print('prev call stack:') # print(id(self.processing_block.call_stack), self.processing_block.call_stack) # print('next call stack:') # print(id(external_block.call_stack), external_block.call_stack) external_block.set_pc(0) external_block.get_machine_state().set_stack( Stack(block_number=new_block_number)) external_block.get_machine_state().set_memory( Memory(block_number=new_block_number)) external_block.add_constraint_to_path_condition(condition) external_block.push_call_stack(continuation_block) # # TODO manage visited address # if not self.visited_address[exec_env.get_exec_env_id()][external_block.get_pc()]: self.basic_blocks.append(external_block) self.__edges[self.processing_block].append(external_block) self.processing_block = external_block # print('next storage:') # print(self.get_processing_block().get_machine_state().get_storage().get_data()) return self.processing_block
def setUp(self): self.stack = Stack(range(1, 6)) self.queue = Queue(range(1, 6)) self.single = SinglyLinkedList() self.double = DoublyLinkedList() self.btree = BinaryTree()
# -*- coding: utf-8 -*- """ Created on Fri Dec 05 17:18:10 2014 @author: ricmark """ import numpy as np import time # 3.4 Towers of Hanoi from data_structures import Stack S1 = Stack() S2 = Stack() S3 = Stack() N = 5 for k in reversed(range(1,N+1)): S1.push(k) def print_towers(): l1, l2, l3 = len(S1.data), len(S2.data), len(S3.data) max_len = N # max(l1,l2,l3) a = np.empty((max_len,3)) a[:] = None if l1 > 0: a[max_len-l1:,0] = [x for x in reversed(S1.data)] if l2 > 0: a[max_len-l2:,1] = [x for x in reversed(S2.data)]
def setUp(self): self.emptyStack = Stack() self.Stack = Stack() for i in range(5): self.Stack.push(i)
class TestStack(unittest.TestCase): # LIFO def setUp(self): self.emptyStack = Stack() self.Stack = Stack() for i in range(5): self.Stack.push(i) def test_repr(self): '''Test returning the stack as a string literal.''' self.assertEqual(repr(self.emptyStack), str(())) tup = (1, 3.14, 'foo', True) for i in tup: self.emptyStack.push(i) self.assertEqual(repr(self.emptyStack), str((True, 'foo', 3.14, 1))) def test_len_size(self): '''Test returning the size of the stack.''' for i in range(100): self.emptyStack.push(i) self.assertEqual(len(self.emptyStack), 100) self.assertEqual(self.emptyStack.size(), 100) self.emptyStack.pop() self.assertEqual(len(self.emptyStack), 99) self.assertEqual(self.emptyStack.size(), 99) def test_tuple(self): '''Test returning the stack as a tuple literal.''' self.assertEqual(tuple(self.emptyStack), ()) tup = (1, 3.14, 'foo', True) for i in tup: self.emptyStack.push(i) self.assertEqual(tuple(self.emptyStack), (True, 'foo', 3.14, 1)) def test_list(self): '''Test returning the stack as a list literal.''' self.assertEqual(list(self.emptyStack), []) li = [1, 3.14, 'foo', True] for i in li: self.emptyStack.push(i) self.assertEqual(list(self.emptyStack), [True, 'foo', 3.14, 1]) def test_push(self): '''Test pushing items on top of the stack.''' self.Stack.push(True) self.assertEqual(tuple(self.Stack), (True, 4, 3, 2, 1, 0)) def test_pop(self): '''Test popping off and returning the top of the stack.''' self.assertEqual(self.Stack.pop(), 4) self.assertEqual(tuple(self.Stack), (3, 2, 1, 0)) self.assertEqual(self.Stack.pop(), 3) self.assertEqual(self.Stack.pop(), 2) self.assertEqual(self.Stack.pop(), 1) self.assertEqual(self.Stack.pop(), 0) self.assertEqual(tuple(self.Stack), ()) with self.assertRaises(ValueError): self.Stack.pop() def test_peek(self): '''Test peeking at the top of the stack w/o modifying the stack.''' self.assertEqual(self.Stack.peek(), 4) with self.assertRaises(ValueError): self.emptyStack.peek()
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)