Ejemplo n.º 1
0
class RemoveRightLeafNodeTestCase(unittest.TestCase):
    def setUp(self) -> None:
        self.tree = BST(None)
        self.tree.AddKeyValue(4, "value_4")
        self.tree.AddKeyValue(2, "value_2")
        self.tree.AddKeyValue(6, "value_6")
        self.tree.AddKeyValue(5, "value_5")
        self.tree.AddKeyValue(7, "value_7")

    def test_left(self):
        self.assertEqual(4, self.tree.Root.NodeKey)
        self.assertEqual(6, self.tree.Root.RightChild.NodeKey)
        self.assertEqual(5, self.tree.Root.RightChild.LeftChild.NodeKey)
        self.assertEqual(7, self.tree.Root.RightChild.RightChild.NodeKey)

        self.tree.DeleteNodeByKey(5)

        self.assertEqual(4, self.tree.Root.NodeKey)
        self.assertEqual(6, self.tree.Root.RightChild.NodeKey)
        self.assertIsNone(self.tree.Root.RightChild.LeftChild)
        self.assertEqual(7, self.tree.Root.RightChild.RightChild.NodeKey)

    def test_right(self):
        self.assertEqual(4, self.tree.Root.NodeKey)
        self.assertEqual(6, self.tree.Root.RightChild.NodeKey)
        self.assertEqual(5, self.tree.Root.RightChild.LeftChild.NodeKey)
        self.assertEqual(7, self.tree.Root.RightChild.RightChild.NodeKey)

        self.tree.DeleteNodeByKey(7)

        self.assertEqual(4, self.tree.Root.NodeKey)
        self.assertEqual(6, self.tree.Root.RightChild.NodeKey)
        self.assertIsNone(self.tree.Root.RightChild.RightChild)
        self.assertEqual(5, self.tree.Root.RightChild.LeftChild.NodeKey)
Ejemplo n.º 2
0
 def setUp(self) -> None:
     self.tree = BST(None)
     self.tree.AddKeyValue(4, "value_4")
     self.tree.AddKeyValue(2, "value_2")
     self.tree.AddKeyValue(6, "value_6")
     self.tree.AddKeyValue(5, "value_5")
     self.tree.AddKeyValue(7, "value_7")
Ejemplo n.º 3
0
class RemoveLeftLeafNodeTestCase(unittest.TestCase):
    def setUp(self) -> None:
        self.tree = BST(None)
        self.tree.AddKeyValue(4, "value_4")
        self.tree.AddKeyValue(2, "value_2")
        self.tree.AddKeyValue(6, "value_6")
        self.tree.AddKeyValue(1, "value_1")
        self.tree.AddKeyValue(3, "value_3")

    def test_left(self):
        self.assertEqual(4, self.tree.Root.NodeKey)
        self.assertEqual(2, self.tree.Root.LeftChild.NodeKey)
        self.assertEqual(1, self.tree.Root.LeftChild.LeftChild.NodeKey)
        self.assertEqual(3, self.tree.Root.LeftChild.RightChild.NodeKey)

        self.tree.DeleteNodeByKey(1)

        self.assertEqual(4, self.tree.Root.NodeKey)
        self.assertEqual(2, self.tree.Root.LeftChild.NodeKey)
        self.assertIsNone(self.tree.Root.LeftChild.LeftChild)
        self.assertEqual(3, self.tree.Root.LeftChild.RightChild.NodeKey)

    def test_right(self):
        self.assertEqual(4, self.tree.Root.NodeKey)
        self.assertEqual(2, self.tree.Root.LeftChild.NodeKey)
        self.assertEqual(1, self.tree.Root.LeftChild.LeftChild.NodeKey)
        self.assertEqual(3, self.tree.Root.LeftChild.RightChild.NodeKey)

        self.tree.DeleteNodeByKey(3)

        self.assertEqual(4, self.tree.Root.NodeKey)
        self.assertEqual(2, self.tree.Root.LeftChild.NodeKey)
        self.assertIsNone(self.tree.Root.LeftChild.RightChild)
        self.assertEqual(1, self.tree.Root.LeftChild.LeftChild.NodeKey)
Ejemplo n.º 4
0
 def setUp(self) -> None:
     self.tree = BST(None)
     self.tree.AddKeyValue(4, "value_4")
     self.tree.AddKeyValue(2, "value_2")
     self.tree.AddKeyValue(6, "value_6")
     self.tree.AddKeyValue(1, "value_1")
     self.tree.AddKeyValue(3, "value_3")
Ejemplo n.º 5
0
def main():
    pass
    b = BST()
    b.insert(12)
    b.insert(9)
    b.insert(13)
    b.preorder()
 def test_WideAllNodes(self):
     self.assertEqual(
         [node.NodeKey for node in list(self.tree.WideAllNodes())],
         [8, 4, 12, 2, 6, 10, 14, 1, 3, 5, 7, 9, 11, 13, 15])
     self.tree = BST(BSTNode(8, 80, None))
     self.assertEqual(
         [node.NodeKey for node in list(self.tree.DeepAllNodes(0))], [8])
Ejemplo n.º 7
0
class RemoveFromTreeWithSeveralNodes(unittest.TestCase):
    def setUp(self) -> None:
        self.tree = BST(None)
        self.tree.AddKeyValue(4, "value_4")

    def test_left(self):
        self.tree.AddKeyValue(2, "value_2")

        self.assertEqual(4, self.tree.Root.NodeKey)
        self.assertEqual(2, self.tree.Root.LeftChild.NodeKey)
        self.assertEqual(4, self.tree.Root.LeftChild.Parent.NodeKey)

        self.tree.DeleteNodeByKey(2)

        self.assertEqual(4, self.tree.Root.NodeKey)
        self.assertIsNone(self.tree.Root.LeftChild)
        self.assertIsNone(self.tree.Root.RightChild)

    def test_right(self):
        self.tree.AddKeyValue(6, "value_2")

        self.assertEqual(4, self.tree.Root.NodeKey)
        self.assertEqual(6, self.tree.Root.RightChild.NodeKey)
        self.assertEqual(4, self.tree.Root.RightChild.Parent.NodeKey)

        self.tree.DeleteNodeByKey(6)

        self.assertEqual(4, self.tree.Root.NodeKey)
        self.assertIsNone(self.tree.Root.LeftChild)
        self.assertIsNone(self.tree.Root.RightChild)
Ejemplo n.º 8
0
class CountTreeWithSingleNodeTestCase(unittest.TestCase):
    def setUp(self) -> None:
        self.tree = BST(None)
        self.tree.AddKeyValue(4, "value_4")

    def test(self):
        self.assertEqual(4, self.tree.Root.NodeKey)
        self.assertEqual(1, self.tree.Count())
Ejemplo n.º 9
0
class FindInEmptyTreeTestCase(unittest.TestCase):
    def setUp(self) -> None:
        self.tree = BST(None)

    def test(self):
        self.assertIsNone(self.tree.Root)
        self.assertIsNone(self.tree.FindNodeByKey(4).Node)
        self.assertFalse(self.tree.FindNodeByKey(4).NodeHasKey)
 def test_DeepAllNodes(self):
     # проверка in-order
     self.assertEqual(
         [node.NodeKey for node in list(self.tree.DeepAllNodes(0))],
         [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15])
     self.tree = BST(BSTNode(8, 80, None))
     self.assertEqual(
         [node.NodeKey for node in list(self.tree.DeepAllNodes(0))], [8])
 def test_DeepAllNodes(self):
     # проверка post-order
     self.assertEqual(
         [node.NodeKey for node in list(self.tree.DeepAllNodes(1))],
         [1, 3, 2, 5, 7, 6, 4, 9, 11, 10, 13, 15, 14, 12, 8])
     self.tree = BST(BSTNode(8, 80, None))
     self.assertEqual(
         [node.NodeKey for node in list(self.tree.DeepAllNodes(0))], [8])
Ejemplo n.º 12
0
class RemoveFromTreeWithSingleNodeTestCase(unittest.TestCase):
    def setUp(self) -> None:
        self.tree = BST(None)
        self.tree.AddKeyValue(4, "value_4")

    def test(self):
        self.assertEqual(4, self.tree.Root.NodeKey)
        self.assertFalse(self.tree.DeleteNodeByKey(10))
        self.assertTrue(self.tree.DeleteNodeByKey(4))
        self.assertEqual(0, self.tree.Count())
Ejemplo n.º 13
0
class BaseBinarySearchTreeTestCase(unittest.TestCase):
    def setUp(self) -> None:
        self.tree = BST(None)
        self.tree.AddKeyValue(4, "value_4")
        self.tree.AddKeyValue(2, "value_2")
        self.tree.AddKeyValue(1, "value_1")
        self.tree.AddKeyValue(3, "value_3")
        self.tree.AddKeyValue(6, "value_6")
        self.tree.AddKeyValue(5, "value_5")
        self.tree.AddKeyValue(7, "value_7")
Ejemplo n.º 14
0
def main(argv):
    tree = BST([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15])
    tree.preorder_traversal(tree.root)
    print("Next largest value of node {} is: {}".format(
        tree.root.left.left.value,
        next_largest(tree.root.left.left).value))
    print("Next largest value of node {} is: {}".format(
        tree.root.left.right.value,
        next_largest(tree.root.left.right).value))
    print("Next largest value of node {} is: {}".format(
        tree.root.left.left.right.value,
        next_largest(tree.root.left.left.right).value))
Ejemplo n.º 15
0
class DeepAllNodesPreOrderInTreeWithSingleNodeTestCase(unittest.TestCase):
    def setUp(self) -> None:
        self.tree = BST(None)
        self.tree.AddKeyValue(4, "value_4")

    def test(self):
        nodes = self.tree.DeepAllNodes(2)
        nodes_values = []

        for node in nodes:
            nodes_values.append(node.NodeKey)

        self.assertListEqual(nodes_values, [4])
Ejemplo n.º 16
0
def find_suspects(people):
    people_inside = BST()
    # min heap (ordered by exit time)
    building = Heap(key=lambda person: person.exit)
    # list of SuspectGroups
    suspects = []
    for person in people:
        next_to_leave = building.top()
        while next_to_leave is not None and not next_to_leave.shares_time_with(
                person):
            same_time = [building.pop()]
            while building.top(
            ) is not None and next_to_leave.exits_at_same_time(building.top()):
                same_time.append(building.pop())
            append_if_are_suspects(suspects, people_inside, next_to_leave)
            for next in same_time:
                people_inside.remove(next)
            next_to_leave = building.top()
        people_inside.insert(person)
        building.push(person)

    while len(people_inside) > 4:
        next_to_leave = [building.pop()]
        while building.top(
        ) is not None and next_to_leave[0].exits_at_same_time(building.top()):
            next_to_leave.append(building.pop())
        append_if_are_suspects(suspects, people_inside, next_to_leave[0])
        for next in next_to_leave:
            people_inside.remove(next)
    return suspects
Ejemplo n.º 17
0
class AddKeyValueToEmptyTreeTestCase(unittest.TestCase):
    def setUp(self) -> None:
        self.tree = BST(None)

    def test(self):
        self.assertIsNone(self.tree.Root)
        self.assertFalse(self.tree.FindNodeByKey(4).NodeHasKey)
        self.assertTrue(self.tree.AddKeyValue(4, "value_4"))

        self.assertEqual(4, self.tree.Root.NodeKey)
        self.assertEqual("value_4", self.tree.Root.NodeValue)
        self.assertIsNone(self.tree.Root.Parent)
        self.assertIsNone(self.tree.Root.LeftChild)
        self.assertIsNone(self.tree.Root.RightChild)
Ejemplo n.º 18
0
class CountWithInitNodeTestCase(unittest.TestCase):
    def setUp(self) -> None:
        self.tree = BST(BSTNode(4, "value_4", None))

    def test(self):
        self.assertEqual(4, self.tree.Root.NodeKey)
        self.assertEqual(1, self.tree.Count())
Ejemplo n.º 19
0
class FindMinMaxInEmptyTreeTestCase(unittest.TestCase):
    def setUp(self) -> None:
        self.tree = BST(None)

    def test(self):
        self.assertIsNone(self.tree.Root)
        self.assertIsNone(self.tree.FinMinMax(None, True))
Ejemplo n.º 20
0
class RemoveFromEmptyTreeTestCase(unittest.TestCase):
    def setUp(self) -> None:
        self.tree = BST(None)

    def test(self):
        self.assertIsNone(self.tree.Root)
        self.assertFalse(self.tree.DeleteNodeByKey(4))
Ejemplo n.º 21
0
class CountEmptyTreeTestCase(unittest.TestCase):
    def setUp(self) -> None:
        self.tree = BST(None)

    def test(self):
        self.assertIsNone(self.tree.Root)
        self.assertEqual(0, self.tree.Count())
Ejemplo n.º 22
0
def binary_search(lst, lst2):
    bst = BST(names_1[0])
    for i in range(len(names_1)):
        if i != 0:
            bst.insert(names_1[i])
    for name_2 in names_2:
        if bst.contains(name_2):
            duplicates.append(name_2)
 def setUp(self):
     # Создание дерева из 15 злементов начиная от корня (8)
     self.tree = BST(BSTNode(8, 80, None))
     self.tree.AddKeyValue(4, 40)
     self.tree.AddKeyValue(12, 120)
     self.tree.AddKeyValue(2, 20)
     self.tree.AddKeyValue(6, 60)
     self.tree.AddKeyValue(10, 100)
     self.tree.AddKeyValue(14, 140)
     self.tree.AddKeyValue(1, 10)
     self.tree.AddKeyValue(3, 30)
     self.tree.AddKeyValue(5, 50)
     self.tree.AddKeyValue(7, 70)
     self.tree.AddKeyValue(9, 90)
     self.tree.AddKeyValue(11, 110)
     self.tree.AddKeyValue(13, 130)
     self.tree.AddKeyValue(15, 150)
Ejemplo n.º 24
0
class AddExistingKeyValueToNotEmptyTreeTestCase(unittest.TestCase):
    def setUp(self) -> None:
        self.tree = BST(None)
        self.tree.AddKeyValue(4, "value_4")
        self.tree.AddKeyValue(2, "value_2")
        self.tree.AddKeyValue(6, "value_6")

    def test(self):
        self.assertEqual(4, self.tree.Root.NodeKey)
        self.assertEqual(2, self.tree.Root.LeftChild.NodeKey)
        self.assertEqual(6, self.tree.Root.RightChild.NodeKey)

        self.assertTrue(self.tree.FindNodeByKey(6).NodeHasKey)
        self.assertTrue(self.tree.FindNodeByKey(2).NodeHasKey)

        self.assertFalse(self.tree.AddKeyValue(6, "value_6"))
        self.assertFalse(self.tree.AddKeyValue(2, "value_2"))
Ejemplo n.º 25
0
class RemoveLeftNotLeafNodeWithRightChildTestCase(unittest.TestCase):
    def setUp(self) -> None:
        self.tree = BST(None)
        self.tree.AddKeyValue(4, "value_4")
        self.tree.AddKeyValue(2, "value_2")
        self.tree.AddKeyValue(6, "value_6")
        self.tree.AddKeyValue(3, "value_3")

    def test(self):
        self.assertEqual(4, self.tree.Root.NodeKey)
        self.assertEqual(2, self.tree.Root.LeftChild.NodeKey)
        self.assertEqual(3, self.tree.Root.LeftChild.RightChild.NodeKey)

        self.tree.DeleteNodeByKey(2)
        self.assertEqual(4, self.tree.Root.LeftChild.Parent.NodeKey)
        self.assertEqual(3, self.tree.Root.LeftChild.NodeKey)
        self.assertIsNone(self.tree.Root.LeftChild.RightChild)
        self.assertIsNone(self.tree.Root.LeftChild.LeftChild)
        self.assertFalse(self.tree.FindNodeByKey(2).NodeHasKey)
Ejemplo n.º 26
0
def get_one_blog_posts(blog_post_id):
    blog_posts = BlogPost.query.all()
    random.shuffle(blog_posts)

    bst = BST()

    for post in blog_posts:
        bst.insert({
            "id": post.id,
            "title": post.title,
            "body": post.body,
            "user_id": post.user_id,
        })

    post = bst.search_blog(blog_post_id)

    if not post:
        return jsonify({"message": "Blog Post not found"}), 404

    return jsonify(post), 200
Ejemplo n.º 27
0
class DeepAllNodesPreOrderInEmptyTreeTestCase(unittest.TestCase):
    def setUp(self) -> None:
        self.tree = BST(None)

    def test(self):
        nodes = self.tree.DeepAllNodes(2)
        nodes_values = []

        for node in nodes:
            nodes_values.append(node.NodeKey)

        self.assertListEqual(nodes_values, [])
Ejemplo n.º 28
0
    def setUp(self) -> None:
        self.tree = BST(None)
        self.tree.AddKeyValue(8, "")
        self.tree.AddKeyValue(4, "")
        self.tree.AddKeyValue(12, "")
        self.tree.AddKeyValue(2, "")
        self.tree.AddKeyValue(6, "")
        self.tree.AddKeyValue(1, "")
        self.tree.AddKeyValue(5, "")
        self.tree.AddKeyValue(7, "")
        self.tree.AddKeyValue(10, "")
        self.tree.AddKeyValue(14, "")
        self.tree.AddKeyValue(11, "")
        self.tree.AddKeyValue(13, "")
        self.tree.AddKeyValue(15, "")
        self.tree.AddKeyValue(16, "")

        self.assertEqual(8, self.tree.Root.NodeKey)
        self.assertEqual(4, self.tree.Root.LeftChild.NodeKey)
        self.assertEqual(2, self.tree.Root.LeftChild.LeftChild.NodeKey)
        self.assertEqual(1,
                         self.tree.Root.LeftChild.LeftChild.LeftChild.NodeKey)
        self.assertEqual(6, self.tree.Root.LeftChild.RightChild.NodeKey)
        self.assertEqual(
            7, self.tree.Root.LeftChild.RightChild.RightChild.NodeKey)
        self.assertEqual(5,
                         self.tree.Root.LeftChild.RightChild.LeftChild.NodeKey)

        self.assertEqual(12, self.tree.Root.RightChild.NodeKey)
        self.assertEqual(10, self.tree.Root.RightChild.LeftChild.NodeKey)
        self.assertEqual(
            11, self.tree.Root.RightChild.LeftChild.RightChild.NodeKey)
        self.assertEqual(14, self.tree.Root.RightChild.RightChild.NodeKey)
        self.assertEqual(
            13, self.tree.Root.RightChild.RightChild.LeftChild.NodeKey)
        self.assertEqual(
            15, self.tree.Root.RightChild.RightChild.RightChild.NodeKey)
        self.assertEqual(
            16,
            self.tree.Root.RightChild.RightChild.RightChild.RightChild.NodeKey)
Ejemplo n.º 29
0
class AddKeyValueToNotEmptyTreeTestCase(unittest.TestCase):
    def setUp(self) -> None:
        self.tree = BST(None)
        self.tree.AddKeyValue(4, "value_4")
        self.tree.AddKeyValue(2, "value_2")
        self.tree.AddKeyValue(6, "value_6")

    def test_left(self):
        self.assertEqual(4, self.tree.Root.NodeKey)
        self.assertEqual(2, self.tree.Root.LeftChild.NodeKey)
        self.assertEqual(6, self.tree.Root.RightChild.NodeKey)
        self.assertFalse(self.tree.FindNodeByKey(1).NodeHasKey)

        self.assertTrue(self.tree.AddKeyValue(1, "value_1"))
        self.assertEqual(2, self.tree.Root.LeftChild.NodeKey)
        self.assertEqual(4, self.tree.Root.LeftChild.Parent.NodeKey)
        self.assertEqual(1, self.tree.Root.LeftChild.LeftChild.NodeKey)
        self.assertEqual(2, self.tree.Root.LeftChild.LeftChild.Parent.NodeKey)

    def test_right(self):
        self.assertEqual(4, self.tree.Root.NodeKey)
        self.assertEqual(2, self.tree.Root.LeftChild.NodeKey)
        self.assertEqual(6, self.tree.Root.RightChild.NodeKey)
        self.assertFalse(self.tree.FindNodeByKey(7).NodeHasKey)

        self.assertTrue(self.tree.AddKeyValue(7, "value_7"))
        self.assertEqual(6, self.tree.Root.RightChild.NodeKey)
        self.assertEqual(4, self.tree.Root.RightChild.Parent.NodeKey)
        self.assertEqual(7, self.tree.Root.RightChild.RightChild.NodeKey)
        self.assertEqual(6,
                         self.tree.Root.RightChild.RightChild.Parent.NodeKey)
class BSTTest(unittest.TestCase):

    def setUp(self):
        self.bst = BST()
        # node0 = BinarySearchTreeNode(1)
        # node1 = BinarySearchTreeNode(2)
        # node2 = BinarySearchTreeNode(3)
        # node3 = BinarySearchTreeNode(4)
        # node4 = BinarySearchTreeNode(5)
        # self.bst.insert(node0)
        # self.bst.insert(node4)
        # self.bst.insert(node2)
        # self.bst.insert(node1)
        # self.bst.insert(node3)

        self.bst.insert(Node(3))
        self.bst.insert(Node(7))
        self.bst.insert(Node(1))
        self.bst.insert(Node(5))
        # self.bst.print_in_order()

    def test_is_valid(self):
        self.assertEqual(True, self.bst.is_valid())
Ejemplo n.º 31
0
def main(argv):
    tree = BST([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15])
    tree.preorder_traversal(tree.root)
    nodea = tree.root.left.left
    nodeb = tree.root.right.left.left
    print("Lowest common ancestor of {} and {} is: {}".format(
        nodea.value, nodeb.value, lowest_common_ancestor(nodea, nodeb)))
    print("Lowest common ancestor of {} and {} is: {}".format(
        nodea.value, nodeb.value,
        lowest_common_ancestor_recursive(nodea, nodeb)))
    nodea = tree.root.left.left
    nodeb = tree.root.left.right.left
    print("Lowest common ancestor of {} and {} is: {}".format(
        nodea.value, nodeb.value, lowest_common_ancestor(nodea, nodeb)))
    print("Lowest common ancestor of {} and {} is: {}".format(
        nodea.value, nodeb.value,
        lowest_common_ancestor_recursive(nodea, nodeb)))
    nodea = tree.root.left.left
    nodeb = tree.root.left.left.right
    print("Lowest common ancestor of {} and {} is: {}".format(
        nodea.value, nodeb.value, lowest_common_ancestor(nodea, nodeb)))
    print("Lowest common ancestor of {} and {} is: {}".format(
        nodea.value, nodeb.value,
        lowest_common_ancestor_recursive(nodea, nodeb)))
    def setUp(self):
        self.bst = BST()
        # node0 = BinarySearchTreeNode(1)
        # node1 = BinarySearchTreeNode(2)
        # node2 = BinarySearchTreeNode(3)
        # node3 = BinarySearchTreeNode(4)
        # node4 = BinarySearchTreeNode(5)
        # self.bst.insert(node0)
        # self.bst.insert(node4)
        # self.bst.insert(node2)
        # self.bst.insert(node1)
        # self.bst.insert(node3)

        self.bst.insert(Node(3))
        self.bst.insert(Node(7))
        self.bst.insert(Node(1))
        self.bst.insert(Node(5))

if __name__ == '__main__':


    # bt
    bt = BT()
    l = [10, 5, 6, 3, 8, 2, 1, 11, 9, 4]
    for i in l:
        bt.add(i)
    print 'BT...'
    print 'Original:    ', l
    print 'Preorder:    ', preorder(bt.root)
    print 'Postorder:   ', postorder(bt.root)
    print 'Inorder:     ', inorder(bt.root)
    print 'Breath:      ', BFT(bt)

    # bst
    bst = BST()
    l = [10, 5, 6, 3, 8, 2, 1, 11, 9, 4]
    for i in l:
        bst.add(i)

    print
    print 'BST ...'
    print 'Original:    ', l
    print 'Preorder:    ', preorder(bst.root)
    print 'Postorder:   ', postorder(bst.root)
    print 'Inorder:     ', inorder(bst.root)
    print 'Breath:      ', BFT(bst)
def find_ancestor2(tree, n1, n2):
    if not tree:
        return False

    if n1 <= tree.item and n2 >= tree.item or (not tree.left and not tree.right) :
        return tree.item

    if tree.left and (n1 < tree.item and n2 < tree.item):
        return find_ancestor(tree.left, n1, n2) or tree.item

    if tree.right and (n1 > tree.item and n2 > tree.item):
        return find_ancestor(tree.right, n1, n2) or tree.item



if __name__ == '__main__':
    bst = BST()
    l = [10, 5, 6, 3, 8, 2, 1, 11, 9, 4]
    for i in l:
        bst.add(i)
    nodes = bst.preorder_array()

    print 'Original:    ', l
    print 'Preorder:    ', nodes

    print 'Method 1: '
    print 'Ancestor for 3, 11:', find_ancestor(nodes, 3, 11)

    print 'Method 2: '
    print 'Ancestor for 3, 11: ', find_ancestor2(bst.root, 3, 11)
    if node.left:
        if node.left.item > node.item or node.left.item > max_node:
            left = False
        else:
            max_node = node.item
            left = isBST(node.left, max_node, min_node)

    if node.right:
        if node.right.item < node.item or node.right.item < min_node:
            rihjt = False
        else:
            min_node = node.item
            right = isBST(node.right, max_node, min_node)

    return left and right


if __name__ == "__main__":
    bt = BST()
    for i in range(1, 10):
        bt.add(i)

    assert isBST(bt.root) == True

    bt = BT()
    for i in range(1, 10):
        bt.add(i)

    assert isBST(bt.root) == False
Ejemplo n.º 36
0
from binary_search_tree import BST

bst = BST()

bst.insert(-1)
bst.insert(0)
bst.insert(1)
bst.insert(2)


print(bst.getMin())
print(bst.getMax())
print(bst.traverseInOrder())