def minimal_tree_recur(elements, low, high): if low == high: return None index = (low + high) // 2 node = BSTNode(elements[index]) node.left = minimal_tree_recur(elements, low, index) node.right = minimal_tree_recur(elements, index + 1, high) return node
def test5_find_one(self): """Calling find for a node which exists should return that node. (1p)""" node = BSTNode(2) node.left = BSTNode(1) node.right = BSTNode(3) self.tree.root = node for node in (node, node.left, node.right): found_node = self.tree.find(node.key) self.assertIs( found_node, node, "If {0!r} exists in tree, calling tree.find({1}) should return that node, not {2!r}" .format(node, node.key, found_node))
def setUp(self): # Root Q = BSTNode(4, "Q") # Internal node P = BSTNode(2, "P") # Leafs A = BSTNode(1, "A") B = BSTNode(3, "B") C = BSTNode(5, "C") # Construct a minimal tree Q.left = P Q.right = C P.left = A P.right = B # Q # / \ # P C # / \ # A B self.nodes = (P, Q, A, B, C) self.tree = AVL()
def setUp(self): # Root P = BSTNode(2, "P") # Internal node Q = BSTNode(4, "Q") # Leafs A = BSTNode(1, "A") B = BSTNode(3, "B") C = BSTNode(5, "C") # Construct a minimal tree P.left = A P.right = Q Q.left = B Q.right = C # P # / \ # A Q # / \ # B C self.nodes = (P, Q, A, B, C) self.tree = AVL()
def setUp(self): A = BSTNode(1, "A") B = BSTNode(3, "B") C = BSTNode(2, "C") B.left = C A.right = B # A # \ # B # / # C self.tree = AVL() self.nodes = (A, B, C)
def test4_node_height_uneven_subtrees(self): """The height of a BSTNode with subtrees of uneven heights is the height of the taller subtree plus one. (0p)""" node = BSTNode(1) node.left = BSTNode(2) node.left.left = BSTNode(3) self.assertEqual( node.left.height(), 1, "Expected the height of a node with one child, which is a leaf, to be 1 but it was not." ) node.right = BSTNode(4) self.assertEqual( node.right.height(), 0, "Expected the height of a leaf to be 0 but it was not.") self.assertEqual( node.height(), node.left.height() + 1, "Expected the height of a node with two children, left and right, of which right is a leaf and left has one child, which is a leaf, to be the height of left plus one but it was not." )
def test3_node_height_one_child(self): """The height of a BSTNode with one child is 1 and the height of that child is 0. (0p)""" node = BSTNode(1) node.left = BSTNode(2) self.assertEqual(node.height(), 1) self.assertEqual(node.left.height(), 0)
def swap(a, b): a.data = b.data b.data = a.data a.data = b.data def swap_nodes_bst(root, first, middle, last, prev): if root is not None: swap_nodes_bst(root.left, first, middle, last, prev) if prev and root.data < prev.data: if not first: first = prev middle = root else: last = root prev = root swap_nodes_bst(root.right, first, middle, last, prev) if __name__ == "__main__": root = BSTNode(4) root.left = BSTNode(2) root.right = BSTNode(6) root.left.left = BSTNode(1) root.left.right = BSTNode(3) root.right.left = BSTNode(5) root.right.right = BSTNode(7)
return get_pair_with_sum_rec(orignl_root, node.left, sum) or \ get_pair_with_sum_rec(orignl_root, node.right, sum) def has_other_pair(root, this_node, rem): if not root: return if root.data == rem and this_node!=root: return root.data elif root.data < rem: return has_other_pair(root.right, this_node, rem) elif root.data > rem: return has_other_pair(root.left, this_node, rem) if __name__ == "__main__": root = BSTNode(4) root.left = BSTNode(2) root.right = BSTNode(6) root.left.left = BSTNode(1) root.left.right = BSTNode(3) root.right.left = BSTNode(5) root.right.right = BSTNode(7) sum = 4 for sum in xrange(1, 15): print get_pair_with_sum(root, sum), print get_pair_with_sum_rec(root, root, sum)