Binary Search Tree

Binary Search Tree

Constructor sets three attributes: data, left subtree and right subtree.

Each node is greater than every node in its left subtree, and is less than every node in its right subtree.

Insert inserts a new subtree into the proper location.
Find finds a value. If value not found, returns False.
Get_size returns the number of nodes in the tree (excluding None nodes).
Preorder prints a preorder traversal of the tree.
Inorder prints an inorder traversal of the tree.

Advantages of Binary Search Trees

1. Because trees use recursion for most operations, they are fairly easy to implement.

2. SPEED: Insert, delete and find in O(log n).

class Tree:
    def __init__(self, data, left=None, right=None):
        self.data = data
        self.left = left
        self.right = right
    def insert(self, data):
        if self.data == data:
            return False # duplicate value
        elif self.data > data:
            if self.left is not None:
                return self.left.insert(data)
            else:
                self.left = Tree(data)
                return True
        else:
            if self.right is not None:
                return self.right.insert(data)
            else:
                self.right = Tree(data)
                return True
    def find(self, data):
        if self.data == data:
            return data
        elif self.data > data:
            if self.left is None:
                return False
            else:
                return self.left.find(data)
        elif self.data < data:
            if self.right is None:
                return False
            else:
                return self.right.find(data)
    def get_size(self):
        if self.left is not None and self.right is not None:
            return 1 + self.left.get_size() + self.right.get_size()
        elif self.left:
            return 1 + self.left.get_size()
        elif self.right:
            return 1 + self.right.get_size()
        else:
            return 1
    def preorder(self):
        if self is not None:
            print (self.data, end=' ')
            if self.left is not None:
                self.left.preorder()
            if self.right:
                self.right.preorder()
    def inorder(self):
        if self is not None:
            if self.left is not None:
                self.left.inorder()
            print (self.data, end=' ') # this line will be executed after left subtree is printed.
            if self.right is not None:
                self.right.inorder()

About pre-order and in-order:

Test Code

We create a new tree, insert one value, insert a whole list of values, find all values from 1 to 15 (False for 0, 5 and 8 shows that those values are not in the tree), print the size of the tree, print preorder and postorder traversals.

tree = Tree(7)
tree.insert(9)
for i in [15, 10, 2, 12, 3, 1, 13, 6, 11, 4, 14, 9]:
    tree.insert(i)
for i in range(16):
    print(tree.find(i), end=' ')
print('\n', tree.get_size())

tree.preorder()
print()
tree.inorder()
print()

False 1 2 3 4 False 6 7 False 9 10 11 12 13 14 15 
 13
7 2 1 3 6 4 9 15 10 12 11 13 14 
1 2 3 4 6 7 9 10 11 12 13 14 15