def test_check_balance(self):
        bst = BstBalance(Node(5))
        assert_equal(bst.check_balance(), True)

        bst.insert(3)
        bst.insert(8)
        bst.insert(1)
        bst.insert(4)
        assert_equal(bst.check_balance(), True)

        bst = BstBalance(Node(5))
        bst.insert(3)
        bst.insert(8)
        bst.insert(9)
        bst.insert(10)
        assert_equal(bst.check_balance(), False)

        bst = BstBalance(Node(3))
        bst.insert(2)
        bst.insert(1)
        bst.insert(5)
        bst.insert(4)
        bst.insert(6)
        bst.insert(7)
        assert_equal(bst.check_balance(), True)

        print('Success: test_check_balance')
 def testHeightV2(self):
     node_2 = Node(2, None, None)
     node_7 = Node(7, None, None)
     node_4 = Node(4, node_2, node_7)
     node_6 = Node(6, None, None)
     node_5 = Node(5, node_4, node_6)
     bst = BST(node_5)
     self.assertEquals(2, bst.get_height(node_5))
Esempio n. 3
0
def test_get():
    root = Node('b', 5)
    root.left = Node('a', 3)
    root.right = Node('c', 2)
    bst = BST(root)

    assert bst.get('a') == 3
    assert bst.get('c') == 2
    assert bst.get('d') is None
 def testRemoveLeafNode2(self):
     node_1 = Node(1, None, None)
     node_2 = Node(2, node_1, None)
     node_3 = Node(4, node_2, None)
     node_4 = Node(6, None, None)
     node_5 = Node(5, node_3, node_4)
     bst = BST(node_5)
     bst.removeNode(None, node_5, 1)
     self.assertEquals(node_2.left, None)
 def testRemoveNodeHasOneChildren(self):
     node_1 = Node(1, None, None)
     node_2 = Node(2, node_1, None)
     node_3 = Node(4, node_2, None)
     node_4 = Node(6, None, None)
     node_5 = Node(5, node_3, node_4)
     bst = BST(node_5)
     bst.removeNode(None, node_5, 2)
     self.assertEquals(node_3.left.data, 1)
Esempio n. 6
0
def BSTRandomTest(tree, size):
    """
    Fills a BST of a given size, with random elements.
    Tests the contents of the BST with an array, after insertions and deletions.
    Returns Tree if the contents of the BST are identical to the array at all times.
    For BST class and subclass testing.
    """
    passed = True
    ar = []

    # insertions
    for i in range(size):
        v = random.randint(-999, 999)
        if v not in ar:
            ar.append(v)
            tree.insert(Node(v))

    ar.sort()
    if not BSTCompare(tree, ar):
        BSTPrintErrorMessage(tree, ar, ", after insertions")
        passed = False

    # known deletions
    for i in range(len(ar) // 2):
        v = ar[i]
        ar.remove(v)
        n = tree.search(v)
        tree.delete(n)

    if not BSTCompare(tree, ar):
        BSTPrintErrorMessage(tree, ar, ", after known deletions")
        passed = False

    # random deletions
    for i in range(size // 2):
        v = random.randint(-1000, 1000)
        if v in ar:
            ar.remove(v)
        n = tree.search(v)
        tree.delete(n)

    if not BSTCompare(tree, ar):
        BSTPrintErrorMessage(tree, ar, ", after random deletions")
        passed = False

    # additional insertions
    for i in range(size // 4):
        v = random.randint(-1000, 1000)
        if v not in ar:
            ar.append(v)
            tree.insert(Node(v))
    ar.sort()
    if not BSTCompare(tree, ar):
        BSTPrintErrorMessage(tree, ar, ", after second insertions")
        passed = False

    return passed
Esempio n. 7
0
def main():
    root = Node(1)
    insert(root, Node(0))
    insert(root, Node(2))
    for i in range(0, 9):
        insert(root, Node(random.randint(0, i)))
    levelOrder(root)
    print 'asdf'
    list_level(root, 3)
    pass
Esempio n. 8
0
def baltree(root, list):
    if not list:
        return

    mid = len(list) / 2
    root.data = list[mid]

    root.left = Node()
    root.right = Node()

    baltree(root.left, list[0: mid])
    baltree(root.right, list[mid + 1:])
Esempio n. 9
0
def main():
    root1 = Node(0)
    root2 = Node(10)
    insert(root2, Node(5))
    insert(root2, Node(7))
    arr = [i for i in range(0, 9)]
    createBstFromSorted(root1, arr, 0, len(arr) - 1)

    levelOrder(root1)
    print 'root2'
    levelOrder(root2)

    print subtree(root1, root2)

    pass
def build_from_PostIn(postorder, inorder):
    if inorder and postorder:
        index = inorder.index(postorder.pop())
        root = Node(inorder[index])
        root.right = build_from_PostIn(postorder, inorder[index + 1:])
        root.left = build_from_PostIn(postorder, inorder[:index])
        return root
 def testInsertThreeNodes(self):
     node_1 = Node(5, None, None)
     bst = BST(node_1)
     bst.insert(node_1, 4)
     bst.insert(node_1, 2)
     bst.insert(node_1, 1)
     self.assertEquals(node_1.left.left.left.data, 1)
    def test_tree_level_lists(self):
        bst = BstLevelLists(Node(5))
        bst.insert(3)
        bst.insert(8)
        bst.insert(2)
        bst.insert(4)
        bst.insert(1)
        bst.insert(7)
        bst.insert(6)
        bst.insert(9)
        bst.insert(10)
        bst.insert(11)

        levels = bst.create_level_lists()
        results_list = []
        for level in levels:
            results = Results()
            for node in level:
                results.add_result(node)
            results_list.append(results)

        assert_equal(str(results_list[0]), '[5]')
        assert_equal(str(results_list[1]), '[3, 8]')
        assert_equal(str(results_list[2]), '[2, 4, 7, 9]')
        assert_equal(str(results_list[3]), '[1, 6, 10]')
        assert_equal(str(results_list[4]), '[11]')

        print('Success: test_tree_level_lists')
def main():
    root = Node(6)
    left = Node(4)
    right = Node(5)
    l1 = Node(3)
    l2 = Node(5)
    insert(left, l1)
    insert(left, l2)

    insert(root, left)
    insert(root, right)
    levelOrder(root)
    print ancestor(root, l1, l2, [False], [False], [False])
    print 'root is ' + str(left)

    pass
Esempio n. 14
0
def main():
    root = Node()

    arr = [i for i in range(0, 7)]
    createBstFromSorted(root, arr, 0, len(arr) - 1)
    levelOrder(root)

    print arr
 def _create_min_bst(self, array, start, end):
     if end < start:
         return None
     mid = (start + end) // 2
     node = Node(array[mid])
     node.left = self._create_min_bst(array, start, mid - 1)
     node.right = self._create_min_bst(array, mid + 1, end)
     return node
def build_from_PreIn(preorder, inorder):
    if inorder and preorder:
        index = inorder.index(preorder[0])
        root = Node(inorder[index])
        root.left = build_from_PreIn(preorder[1:index + 1], inorder[:index])
        root.right = build_from_PreIn(preorder[index + 1:],
                                      inorder[index + 1:])
        return root
Esempio n. 17
0
def createBstFromSorted(root, arr, start, end):
    if not root:
        return

    if start > end:
        root = None

        return
    mid = (start + end) / 2
    root.data = arr[mid]

    if not start > (mid - 1):
        root.left = Node()
        createBstFromSorted(root.left, arr, start, mid - 1)
    if not (mid + 1) > end:
        root.right = Node()
        createBstFromSorted(root.right, arr, mid + 1, end)
 def testInsertFourNodes(self):
     node_1 = Node(5, None, None)
     bst = BST(node_1)
     bst.insert(node_1, 4)
     bst.insert(node_1, 2)
     bst.insert(node_1, 1)
     bst.insert(node_1, 6)
     self.assertEquals(node_1.right.data, 6)
Esempio n. 19
0
    def test_bst_validate(self):
        bst = BstValidate(Node(5))
        bst.insert(8)
        bst.insert(5)
        bst.insert(6)
        bst.insert(4)
        bst.insert(7)
        assert_equal(bst.validate(), True)

        bst = BstValidate(Node(5))
        left = Node(5)
        right = Node(8)
        invalid = Node(20)
        bst.root.left = left
        bst.root.right = right
        bst.root.left.right = invalid
        assert_equal(bst.validate(), False)

        print('Success: test_bst_validate')
Esempio n. 20
0
def BSTFromArray(arr):
    """
    Creates a BST from the keys in a given array.
    type arr: List[]
    rtype: BST
    """
    tree = BST()
    for k in arr:
        tree.insert(Node(k))
    return tree
    def test_bfs(self):
        bst = BstBfs(Node(5))
        bst.insert(2)
        bst.insert(8)
        bst.insert(1)
        bst.insert(3)
        bst.bfs(self.results.add_result)
        assert_equal(str(self.results), '[5, 2, 8, 1, 3]')

        print('Success: test_bfs')
    def test_height(self):
        bst = BstHeight(Node(5))
        assert_equal(bst.height(bst.root), 1)
        bst.insert(2)
        bst.insert(8)
        bst.insert(1)
        bst.insert(3)
        assert_equal(bst.height(bst.root), 3)

        print('Success: test_height')
Esempio n. 23
0
 def test_bst_second_largest(self):
     bst = Solution(None)
     assert_raises(TypeError, bst.find_second_largest)
     root = Node(10)
     bst = Solution(root)
     node5 = bst.insert(5)
     node15 = bst.insert(15)
     node3 = bst.insert(3)
     node8 = bst.insert(8)
     node12 = bst.insert(12)
     node20 = bst.insert(20)
     node2 = bst.insert(2)
     node4 = bst.insert(4)
     node30 = bst.insert(30)
     assert_equal(bst.find_second_largest(), node20)
     root = Node(10)
     bst = Solution(root)
     node5 = bst.insert(5)
     node3 = bst.insert(3)
     node7 = bst.insert(7)
     assert_equal(bst.find_second_largest(), node7)
     print('Success: test_bst_second_largest')
 def testFoundSearch(self):
     node_5 = Node(5, None, None)
     bst = BST(node_5)
     bst.insert(node_5, 4)
     bst.insert(node_5, 2)
     bst.insert(node_5, 1)
     bst.insert(node_5, 3)
     bst.insert(node_5, 6)
     bst.insert(node_5, 7)
     bst.insert(node_5, 8)
     bst.insert(node_5, 0)
     bst.printAllNodes()
     self.assertTrue(bst.search(node_5, 7))
 def testRemoveNodeHasTwoChildrenRightSubtree(self):
     node_5 = Node(5, None, None)
     bst = BST(node_5)
     bst.insert(node_5, 4)
     bst.insert(node_5, 2)
     bst.insert(node_5, 1)
     bst.insert(node_5, 3)
     bst.insert(node_5, 6)
     bst.insert(node_5, 7)
     bst.insert(node_5, 8)
     bst.insert(node_5, 0)
     bst.removeNode(None, node_5, 7)
     self.assertFalse(bst.search(node_5, 7))
Esempio n. 26
0
 def print_Trees(first, last):
     trees = []
     for i in range(first, last + 1):
         for j in print_Trees(first, i - 1):
             for y in print_Trees(i + 1, last):
                 # print("hi")
                 BT = Binary_Tree()
                 root = Node(i)
                 root.left = j
                 root.right = y
                 BT.root = root
                 trees.append(root)
     return trees or [None]
 def testNotFoundSearch(self):
     node_5 = Node(5, None, None)
     bst = BST(node_5)
     bst.insert(node_5, 4)
     bst.insert(node_5, 2)
     bst.insert(node_5, 1)
     bst.insert(node_5, 3)
     bst.insert(node_5, 6)
     bst.insert(node_5, 7)
     bst.insert(node_5, 8)
     bst.insert(node_5, 0)
     bst = BST(node_5)
     self.assertFalse(bst.search(node_5, 9))
Esempio n. 28
0
def AVLFullTest():
    for i in range(30):
        tree = AVL()
        passed = BSTRandomTest(tree, 1000)

        if passed:
            height = tree.height()
            arr = tree.inorderWalk()
            max_height = round(1.44 * math.log(len(arr), 2) - 1, 1)
            if height > max_height:
                s = "but height exceeded expectations: "
            else:
                s = "and height within expectations: "
            s += "actual " + str(height) + " vs. expected " + str(max_height)
            print "Passed test", i + 1, s

    tree = AVL()
    ar = []
    for i in range(16):
        v = random.randint(-99, 99)
        if v not in ar:
            tree.insert(Node(v))
            ar.append(v)
    ar.sort()

    print "Height =", tree.height()
    print "Max. expected height =", round(1.44 * math.log(len(ar) + 1, 2) - 1,
                                          1)
    print "Minimum =", tree.minimum()
    print "Maximum =", tree.maximum()
    print "In-order Walk =", tree.inorderWalk()
    print "Array =", ar
    print "Tree ="
    print tree

    for i in range(3):
        index = random.randint(0, len(ar) - 1)
        v = ar[index]
        tree.delete(tree.search(v))
        ar.remove(v)

    print "Height =", tree.height()
    print "Max. expected height =", round(1.44 * math.log(len(ar) + 1, 2) - 1,
                                          1)
    print "Minimum =", tree.minimum()
    print "Maximum =", tree.maximum()
    print "In-order Walk =", tree.inorderWalk()
    print "Array =", ar
    print "Tree ="
    print tree
    def test_dfs(self):
        bst = BstDfs(Node(5))
        bst.insert(2)
        bst.insert(8)
        bst.insert(1)
        bst.insert(3)

        bst.in_order_traversal(bst.root, self.results.add_result)
        assert_equal(str(self.results), "[1, 2, 3, 5, 8]")
        self.results.clear_results()

        bst.pre_order_traversal(bst.root, self.results.add_result)
        assert_equal(str(self.results), "[5, 2, 1, 3, 8]")
        self.results.clear_results()

        bst.post_order_traversal(bst.root, self.results.add_result)
        assert_equal(str(self.results), "[1, 3, 2, 8, 5]")
        self.results.clear_results()

        bst = BstDfs(Node(1))
        bst.insert(2)
        bst.insert(3)
        bst.insert(4)
        bst.insert(5)

        bst.in_order_traversal(bst.root, self.results.add_result)
        assert_equal(str(self.results), "[1, 2, 3, 4, 5]")
        self.results.clear_results()

        bst.pre_order_traversal(bst.root, self.results.add_result)
        assert_equal(str(self.results), "[1, 2, 3, 4, 5]")
        self.results.clear_results()

        bst.post_order_traversal(bst.root, self.results.add_result)
        assert_equal(str(self.results), "[5, 4, 3, 2, 1]")

        print('Success: test_dfs')
 def handle_BST(self):
     print "How many nodes would you like to include in the binary search tree?"
     num_nodes = raw_input(">")
     print "Please enter the root node"
     root_node_data = raw_input(">")
     root_node = Node(data=root_node_data,
                      left=None,
                      right=None,
                      is_root=True)
     bst = BST(root_node)
     for i in range(int(num_nodes) - 1):
         print "Please enter node val"
         val = raw_input(">")
         bst.insert(bst.root, val)
     print "Your final binary search tree is, in the form [Current, Left Node, Right Node]\n", bst.printAllNodes(
     )