Binary Search Tree In Python

Last Updated : 10 Feb, 2025

A Binary search tree is a binary tree where the values of the left sub-tree are less than the root node and the values of the right sub-tree are greater than the value of the root node. In this article, we will discuss the binary search tree in Python.

What is a Binary Search Tree(BST)?

A Binary Search Tree is a data structure used in computer science for organizing and storing data in a sorted manner. Each node in a Binary Search Tree has at most two children, a left child and a right child.

Properties of BST

The left side of a node only has smaller values.
The right side of a node only has bigger values.
Both the left and right sides follow the same rule, forming a smaller binary search tree.

In this binary tree

Root node: 8
Left subtree (3): values < 8
Right subtree (10): values > 8
Each subtree maintains the same rule, with values relative to their respective roots.

Creation of Binary Search Tree (BST) in Python

Below, are the steps to create a Binary Search Tree (BST).

Create a class Tree
In the parameterized constructor, we have the default parameter val = None
When the Tree class is instantiated without any parameter then it creates an empty node with left and right pointers
If we pass the value while instantiating then it creates a node having that value and left, right pointers are created with None Types.

Python

class Node:     def __init__(self, key):         self.value = key           self.left = None           self.right = None      # Creating the root node root = Node(5)

Time complexity: O(1)
Space complexity: O(1)

Basic Operations on Binary Search Tree (BST)

Below, are the some basic Operations of Binary Search Tree(BST) in Python.

Insertion in Binary Search Tree(BST) in Python

Inserting a node in a Binary search tree involves adding a new node to the tree while maintaining the binary search tree (BST) property. So we need to traverse through all the nodes till we find a leaf node and insert the node as the left or right child based on the value of that leaf node. So the three conditions that we need to check at the leaf node are listed below:

Illustrations

Let us insert 13 into the below Binary search tree

Binary Search Tree

When we call the insert method then 13 is checked with the root node which is 15 , Since 13 < 15 we need to insert 13 to the left sub tree. So we recursively call left_sub_tree.insert(13)
Now the left child of 15 is 10 so 13 is checked with 10 and since 13>10 we need to insert 13 to the right sub tree. So we recursively call right_sub_tree.insert(13)
Here, the right child of 10 is 11 so 13 is checked with 11 and since 13>11 and we need to insert 13 to the right child of 11. Again we recursively call right_sub_tree.insert(13)
In this recursion call, we found there is no node which means we reached till the leaf node, so we create a node and insert the data in the node
After inserting 13 , the BST looks like this :

Inserted 13 Node in Binary Search Tree

Insertion in Binary Search Tree (BST) in Python

Python

# Python program to demonstrate # insert operation in binary search tree class Node:     def __init__(self, key):         self.left = None         self.right = None         self.val = key   # A utility function to insert # a new node with the given key def insert(root, key):     if root is None:         return Node(key)     if root.val == key:             return root     if root.val < key:             root.right = insert(root.right, key)     else:             root.left = insert(root.left, key)     return root   # A utility function to do inorder tree traversal def inorder(root):     if root:         inorder(root.left)         print(root.val, end=" ")         inorder(root.right)   r = Node(15) r = insert(r, 10) r = insert(r, 18) r = insert(r, 4) r = insert(r, 11) r = insert(r, 16) r = insert(r, 20) r = insert(r, 13)  # Print inorder traversal of the BST inorder(r)

Output

4 10 11 13 15 16 18 20

Time Complexity:

The worst-case time complexity of insert operations is O(h) where h is the height of the Binary Search Tree.
In the worst case, we may have to travel from the root to the deepest leaf node. The height of a skewed tree may become n and the time complexity of insertion operation may become O(n).

Auxiliary Space: The auxiliary space complexity of insertion into a binary search tree is O(1)

Searching in Binary Search Tree in Python

Searching in Binary Search Tree is very easy because we don't need to traverse all the nodes. It is based on the value of nodes,which means if the value is less than root then we search in the left sub tree or else we search in right sub tree.

Illustrations

Steps to search a value 'v' in BST:
The value is checked with the root node, if it is equal to the root node then it returns the value
If the value is less than root node then it recursively calls the search operation in the left sub tree
If the value is greater than root node then it recursively calls the search operation in the right sub tree

Binary Search Tree

In above example BST search for value '8' begins from the root node.
If the value is not equal to the current node's value, the search continues recursively on the left subtree if the value is less than the current node's value.
Once the value matches a node, the search terminates, returning the node containing the value.

Searching in Binary Search Tree (BST) in Python

Python

class Node:     def __init__(self, key):         self.key = key         self.left = None         self.right = None  # function to search a key in a BST def search(root, key):        # Base Cases: root is null or key      # is present at root     if root is None or root.key == key:         return root          # Key is greater than root's key     if root.key < key:         return search(root.right, key)          # Key is smaller than root's key     return search(root.left, key)    # Creating a hard coded tree for keeping   # the length of the code small. We need   # to make sure that BST properties are   # maintained if we try some other cases. root = Node(50) root.left = Node(30) root.right = Node(70) root.left.left = Node(20) root.left.right = Node(40) root.right.left = Node(60) root.right.right = Node(80)  # Searching for keys in the BST print("Found" if search(root, 19) else "Not Found") print("Found" if search(root, 80) else "Not Found")

Output

Not Found Found

Time complexity: O(h), where h is the height of the BST.
Auxiliary Space: O(h) This is because of the space needed to store the recursion stack.

Deletion in Binary Search Tree in Python

Deleting a node in Binary search tree involves deleting an existing node while maintaining the properties of Binary Search Tree(BST). we need to search the node which needs to be deleted and then delete it.

Case 1 : While deleting a node having both left child and right child

After finding the node to be deleted, copy the value of right child to v and copy the right child's left pointer to left of v and right pointer

Untitled-Diagramdrawio-(6) — Delete node 18 in BST

In the above example, suppose we need to delete 18 then we need to replace 18 with the maximum value of its left or right sub tree
Let us replace it with 20 which is maximum value of right sub tree
So after deleting 18, the Binary search tree looks like this

Case 2 : While deleting a node having either left child or right child

After finding the node to be deleted, we need to replace the value in the node with its left node it has left child or right node if it has right child.

Untitled-Diagramdrawio-(8) — Delete 16 in BST

In the above example, suppose we need to delete 16 then we need to replace 16 with the value of its right child node
So it will be replaced with 17 which is the value of its right child node
So after deleting 16, the Binary search tree looks like this

Untitled-Diagram-(4) — Deleted 16 in BST

Case 3 : While deleting a leaf node(a node which has no child)

Untitled-Diagramdrawio-(9) — Delete 4 in BST

In the above example, suppose we need to delete 4 which is a leaf node.
Simply we change value of the node, left and right pointers to None.
After deleting 4 the BST looks like this:

Deletion in Binary Search Tree in Python

Python

class Node:     def __init__(self, key):         self.key = key         self.left = None         self.right = None  # Note that it is not a generic inorder successor  # function. It mainly works when the right child # is not empty, which is  the case we need in BST # delete. def get_successor(curr):     curr = curr.right     while curr is not None and curr.left is not None:         curr = curr.left     return curr  # This function deletes a given key x from the # given BST and returns the modified root of the  # BST (if it is modified). def del_node(root, x):        # Base case     if root is None:         return root      # If key to be searched is in a subtree     if root.key > x:         root.left = del_node(root.left, x)     elif root.key < x:         root.right = del_node(root.right, x)              else:         # If root matches with the given key          # Cases when root has 0 children or          # only right child         if root.left is None:             return root.right          # When root has only left child         if root.right is None:             return root.left          # When both children are present         succ = get_successor(root)         root.key = succ.key         root.right = del_node(root.right, succ.key)              return root  # Utility function to do inorder traversal def inorder(root):     if root is not None:         inorder(root.left)         print(root.key, end=" ")         inorder(root.right)  # Driver code if __name__ == "__main__":     root = Node(10)     root.left = Node(5)     root.right = Node(15)     root.right.left = Node(12)     root.right.right = Node(18)     x = 15      root = del_node(root, x)     inorder(root)     print()

Output

5 10 12 18

Time Complexity: O(h), where h is the height of the BST.
Auxiliary Space: O(h).

Traversals in Binary Search Tree in Python

Below, are the traversals of Binary Search Tree (BST) in Python which we can perform as SImilar to Binary Tree.

Traversals in BST in Python

Python

# Python3 code to implement the approach  # Class describing a node of tree class Node:     def __init__(self, v):         self.left = None         self.right = None         self.data = v  # Inorder Traversal def printInorder(root):     if root:         # Traverse left subtree         printInorder(root.left)                  # Visit node         print(root.data,end=" ")                  # Traverse right subtree         printInorder(root.right)  # Driver code if __name__ == "__main__":     # Build the tree     root = Node(100)     root.left = Node(20)     root.right = Node(200)     root.left.left = Node(10)     root.left.right = Node(30)     root.right.left = Node(150)     root.right.right = Node(300)      # Function call     print("Inorder Traversal:",end=" ")     printInorder(root)      # This code is contributed by ajaymakvana.

Output

Inorder Traversal: 10 20 30 100 150 200 300

Time complexity: O(N), Where N is the number of nodes.
Auxiliary Space: O(h), Where h is the height of tree

Applications of BST:

Graph algorithms: BSTs can be used to implement graph algorithms, such as in minimum spanning tree algorithms.
Priority Queues: BSTs can be used to implement priority queues, where the element with the highest priority is at the root of the tree, and elements with lower priority are stored in the subtrees.
Self-balancing binary search tree: BSTs can be used as a self-balancing data structures such as AVL tree and Red-black tree.
Data storage and retrieval: BSTs can be used to store and retrieve data quickly, such as in databases, where searching for a specific record can be done in logarithmic time.

Advantages:

Fast search: Searching for a specific value in a BST has an average time complexity of O(log n), where n is the number of nodes in the tree. This is much faster than searching for an element in an array or linked list, which have a time complexity of O(n) in the worst case.
In-order traversal: BSTs can be traversed in-order, which visits the left subtree, the root, and the right subtree. This can be used to sort a dataset.
Space efficient: BSTs are space efficient as they do not store any redundant information, unlike arrays and linked lists.

Disadvantages:

Skewed trees: If a tree becomes skewed, the time complexity of search, insertion, and deletion operations will be O(n) instead of O(log n), which can make the tree inefficient.
Additional time required: Self-balancing trees require additional time to maintain balance during insertion and deletion operations.
Efficiency: BSTs are not efficient for datasets with many duplicates as they will waste space.

Binary Search Tree

mohithsharmajf3o

Improve

Article Tags :

Practice Tags :

Binary Search Tree In Python

What is a Binary Search Tree(BST)?

Properties of BST

Creation of Binary Search Tree (BST) in Python

Basic Operations on Binary Search Tree (BST)

Insertion in Binary Search Tree(BST) in Python

Illustrations

Searching in Binary Search Tree in Python

Illustrations

Deletion in Binary Search Tree in Python

Traversals in Binary Search Tree in Python

Applications of BST:

Advantages:

Disadvantages:

Similar Reads