# Binary Search Tree | Set 1 (Search and Insertion)

• Difficulty Level : Easy
• Last Updated : 02 Jan, 2023

### What is Binary Search Tree?

A binary Search Tree is a node-based binary tree data structure which has the following properties:

• The left subtree of a node contains only nodes with keys lesser than the node’s key.
• The right subtree of a node contains only nodes with keys greater than the node’s key.
• The left and right subtree each must also be a binary search tree.
There must be no duplicate nodes.

The above properties of the Binary Search Tree provide an ordering among keys so that the operations like search, minimum and maximum can be done fast. If there is no order, then we may have to compare every key to search for a given key.

### How to search a key in given Binary Tree?

For searching a value, if we had a sorted array we could have performed a binary search. Let’s say we want to search a number in the array, in binary search, we first define the complete list as our search space, the number can exist only within the search space. Now we compare the number to be searched or the element to be searched with the middle element (median) of the search space and if the record being searched is less than the middle element, we go searching in the left half, else we go searching in the right half, in case of equality we have found the element. In binary search, we start with â€˜nâ€™ elements in search space and if the mid element is not the element that we are looking for, we reduce the search space to â€˜n/2â€™ we keep reducing the search space until we either find the record that we are looking for or we get to only one element in search space and be done with this whole reduction.

Search operations in binary search trees will be very similar. Let’s say we want to search for the number, we start at the root, and then we compare the value to be searched with the value of the root, if it’s equal we are done with the search if it’s smaller we know that we need to go to the left subtree because in a binary search tree all the elements in the left subtree are smaller and all the elements in the right subtree are larger. Searching an element in the binary search tree is basically this traversal, at each step we go either left or right and at each step we discard one of the sub-trees. If the tree is balanced (we call a tree balanced if for all nodes the difference between the heights of left and right subtrees is not greater than one) we start with a search space of â€˜nâ€™ nodes and as we discard one of the sub-trees, we discard â€˜n/2â€™ nodes so our search space gets reduced to â€˜n/2â€™. In the next step, we reduce the search space to â€˜n/4â€™ and we repeat until we find the element or our search space is reduced to only one node. The search here is also a binary search hence the name; Binary Search Tree.

Implementation:

## C++

 // C function to search a given key in a given BSTstruct node* search(struct node* root, int key){    // Base Cases: root is null or key is present at root    if (root == NULL || 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);}

## Java

 // A utility function to search a given key in BSTpublic Node search(Node root, int key){    // Base Cases: root is null or key is present at root    if (root==null || 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);}

## Python

 # A utility function to search a given key in BSTdef search(root,key):         # Base Cases: root is null or key is present at root    if root is None or root.val == key:        return root     # Key is greater than root's key    if root.val < key:        return search(root.right,key)       # Key is smaller than root's key    return search(root.left,key) # This code is contributed by Bhavya Jain

## C#

 // A utility function to search// a given key in BSTpublic Node search(Node root,                   int key){    // Base Cases: root is null    // or key is present at root    if (root == null ||        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);} // This code is contributed by gauravrajput1

## Javascript



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

Illustration to search 6 in below tree:

1. Start from the root.
2. Compare the searching element with root, if less than root, then recursively call left subtree, else recursively call right subtree.
3. If the element to search is found anywhere, return true, else return false.

Insertion of a key :

A new key is always inserted at the leaf. We start searching for a key from the root until we hit a leaf node. Once a leaf node is found, the new node is added as a child of the leaf node.

100                               100

/   \        Insert 40            /    \

20     500    ———>          20     500

/  \                              /  \

10   30                           10   30

\

40

Implementation:

## C++

 // C++ program to demonstrate insertion// in a BST recursively.#include using namespace std; class BST {    int data;    BST *left, *right; public:    // Default constructor.    BST();     // Parameterized constructor.    BST(int);     // Insert function.    BST* Insert(BST*, int);     // Inorder traversal.    void Inorder(BST*);}; // Default Constructor definition.BST ::BST()    : data(0)    , left(NULL)    , right(NULL){} // Parameterized Constructor definition.BST ::BST(int value){    data = value;    left = right = NULL;} // Insert function definition.BST* BST ::Insert(BST* root, int value){    if (!root) {        // Insert the first node, if root is NULL.        return new BST(value);    }     // Insert data.    if (value > root->data) {        // Insert right node data, if the 'value'        // to be inserted is greater than 'root' node data.         // Process right nodes.        root->right = Insert(root->right, value);    }    else if (value < root->data){        // Insert left node data, if the 'value'        // to be inserted is smaller than 'root' node data.         // Process left nodes.        root->left = Insert(root->left, value);    }     // Return 'root' node, after insertion.    return root;} // Inorder traversal function.// This gives data in sorted order.void BST ::Inorder(BST* root){    if (!root) {        return;    }    Inorder(root->left);    cout << root->data << endl;    Inorder(root->right);} // Driver codeint main(){    BST b, *root = NULL;    root = b.Insert(root, 50);    b.Insert(root, 30);    b.Insert(root, 20);    b.Insert(root, 40);    b.Insert(root, 70);    b.Insert(root, 60);    b.Insert(root, 80);     b.Inorder(root);    return 0;} // This code is contributed by pkthapa

## C

 // C program to demonstrate insert// operation in binary// search tree.#include #include  struct node {    int key;    struct node *left, *right;}; // A utility function to create a new BST nodestruct node* newNode(int item){    struct node* temp        = (struct node*)malloc(sizeof(struct node));    temp->key = item;    temp->left = temp->right = NULL;    return temp;} // A utility function to do inorder traversal of BSTvoid inorder(struct node* root){    if (root != NULL) {        inorder(root->left);        printf("%d \n", root->key);        inorder(root->right);    }} /* A utility function to insert   a new node with given key in * BST */struct node* insert(struct node* node, int key){    /* If the tree is empty, return a new node */    if (node == NULL)        return newNode(key);     /* Otherwise, recur down the tree */    if (key < node->key)        node->left = insert(node->left, key);    else if (key > node->key)        node->right = insert(node->right, key);     /* return the (unchanged) node pointer */    return node;} // Driver Codeint main(){    /* Let us create following BST              50           /     \          30      70         /  \    /  \       20   40  60   80 */    struct node* root = NULL;    root = insert(root, 50);    insert(root, 30);    insert(root, 20);    insert(root, 40);    insert(root, 70);    insert(root, 60);    insert(root, 80);     // print inoder traversal of the BST    inorder(root);     return 0;}

## Java

 // Java program to demonstrateimport java.io.*;// insert operation in binary// search treeclass BinarySearchTree {     /* Class containing left       and right child of current node     * and key value*/    class Node {        int key;        Node left, right;         public Node(int item)        {            key = item;            left = right = null;        }    }     // Root of BST    Node root;     // Constructor    BinarySearchTree() { root = null; }     BinarySearchTree(int value) { root = new Node(value); }     // This method mainly calls insertRec()    void insert(int key) { root = insertRec(root, key); }     /* A recursive function to       insert a new key in BST */    Node insertRec(Node root, int key)    {         /* If the tree is empty,           return a new node */        if (root == null) {            root = new Node(key);            return root;        }         /* Otherwise, recur down the tree */        else if (key < root.key)            root.left = insertRec(root.left, key);        else if (key > root.key)            root.right = insertRec(root.right, key);         /* return the (unchanged) node pointer */        return root;    }     // This method mainly calls InorderRec()    void inorder() { inorderRec(root); }     // A utility function to    // do inorder traversal of BST    void inorderRec(Node root)    {        if (root != null) {            inorderRec(root.left);            System.out.println(root.key);            inorderRec(root.right);        }    }     // Driver Code    public static void main(String[] args)    {        BinarySearchTree tree = new BinarySearchTree();         /* Let us create following BST              50           /     \          30      70         /  \    /  \       20   40  60   80 */        tree.insert(50);        tree.insert(30);        tree.insert(20);        tree.insert(40);        tree.insert(70);        tree.insert(60);        tree.insert(80);         // print inorder traversal of the BST        tree.inorder();    }}// This code is contributed by Ankur Narain Verma

## Python

 # Python program to demonstrate# insert operation in binary search tree # A utility class that represents# an individual node in a BST  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)    else:        if root.val == key:            return root        elif 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)        inorder(root.right)  # Driver program to test the above functions# Let us create the following BST#    50#  /     \# 30     70#  / \ / \# 20 40 60 80 r = Node(50)r = insert(r, 30)r = insert(r, 20)r = insert(r, 40)r = insert(r, 70)r = insert(r, 60)r = insert(r, 80) # Print inoder traversal of the BSTinorder(r)

## C#

 // C# program to demonstrate// insert operation in binary// search treeusing System; class BinarySearchTree {     // Class containing left and    // right child of current node    // and key value    public class Node {        public int key;        public Node left, right;         public Node(int item)        {            key = item;            left = right = null;        }    }     // Root of BST    Node root;     // Constructor    BinarySearchTree() { root = null; }     BinarySearchTree(int value) { root = new Node(value); }     // This method mainly calls insertRec()    void insert(int key) { root = insertRec(root, key); }     // A recursive function to insert    // a new key in BST    Node insertRec(Node root, int key)    {         // If the tree is empty,        // return a new node        if (root == null) {            root = new Node(key);            return root;        }         // Otherwise, recur down the tree        if (key < root.key)            root.left = insertRec(root.left, key);        else if (key > root.key)            root.right = insertRec(root.right, key);         // Return the (unchanged) node pointer        return root;    }     // This method mainly calls InorderRec()    void inorder() { inorderRec(root); }     // A utility function to    // do inorder traversal of BST    void inorderRec(Node root)    {        if (root != null) {            inorderRec(root.left);            Console.WriteLine(root.key);            inorderRec(root.right);        }    }     // Driver Code    public static void Main(String[] args)    {        BinarySearchTree tree = new BinarySearchTree();         /* Let us create following BST              50           /     \          30      70         /  \    /  \       20   40  60   80 */        tree.insert(50);        tree.insert(30);        tree.insert(20);        tree.insert(40);        tree.insert(70);        tree.insert(60);        tree.insert(80);         // Print inorder traversal of the BST        tree.inorder();    }} // This code is contributed by aashish1995

## Javascript



Output

20
30
40
50
60
70
80

Illustration to insert 2 in the below tree:

1.  Start from the root.
2. Compare the inserting element with the root, if less than the root, then recursively call the left subtree, else recursively call the right subtree.
3. After reaching the end, just insert that node at left(if less than current) or else right.

Time Complexity: The worst-case time complexity of search and 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 the search and insert operation may become O(n).
Auxiliary Space: O(1)

Implementation: Insertion using the loop.

## C++

 // C++ Code to insert node and to print inorder traversal// using iteration#include using namespace std; // BST Nodeclass Node {public:    int val;    Node* left;    Node* right;    Node(int val)        : val(val)        , left(NULL)        , right(NULL)    {    }}; // Utility function to insert node in BSTvoid insert(Node*& root, int key){    Node* node = new Node(key);    if (!root) {        root = node;        return;    }    Node* prev = NULL;    Node* temp = root;    while (temp) {        if (temp->val > key) {            prev = temp;            temp = temp->left;        }        else if (temp->val < key) {            prev = temp;            temp = temp->right;        }    }    if (prev->val > key)        prev->left = node;    else        prev->right = node;} // Utiltiy function to print inorder traversalvoid inorder(Node* root){    Node* temp = root;    stack st;    while (temp != NULL || !st.empty()) {        if (temp != NULL) {            st.push(temp);            temp = temp->left;        }        else {            temp = st.top();            st.pop();            cout << temp->val << " ";            temp = temp->right;        }    }} // Driver codeint main(){    Node* root = NULL;    insert(root, 30);    insert(root, 50);    insert(root, 15);    insert(root, 20);    insert(root, 10);    insert(root, 40);    insert(root, 60);     inorder(root);     return 0;} // This code is contributed by Tapesh(tapeshdua420)

## Java

 import java.io.*;import java.util.*; class GFG {    public static void main(String[] args)    {        BST tree = new BST();        tree.insert(30);        tree.insert(50);        tree.insert(15);        tree.insert(20);        tree.insert(10);        tree.insert(40);        tree.insert(60);        tree.inorder();    }} class Node {    Node left;    int val;    Node right;    Node(int val) { this.val = val; }} class BST {    Node root;     public void insert(int key)    {        Node node = new Node(key);        if (root == null) {            root = node;            return;        }        Node prev = null;        Node temp = root;        while (temp != null) {            if (temp.val > key) {                prev = temp;                temp = temp.left;            }            else if (temp.val < key) {                prev = temp;                temp = temp.right;            }        }        if (prev.val > key)            prev.left = node;        else            prev.right = node;    }     public void inorder()    {        Node temp = root;        Stack stack = new Stack<>();        while (temp != null || !stack.isEmpty()) {            if (temp != null) {                stack.add(temp);                temp = temp.left;            }            else {                temp = stack.pop();                System.out.print(temp.val + " ");                temp = temp.right;            }        }    }}

## Python3

 class GFG:    @staticmethod    def main(args):        tree = BST()        tree.insert(30)        tree.insert(50)        tree.insert(15)        tree.insert(20)        tree.insert(10)        tree.insert(40)        tree.insert(60)        tree.inorder()  class Node:    left = None    val = 0    right = None     def __init__(self, val):        self.val = val  class BST:    root = None     def insert(self, key):        node = Node(key)        if (self.root == None):            self.root = node            return        prev = None        temp = self.root        while (temp != None):            if (temp.val > key):                prev = temp                temp = temp.left            elif(temp.val < key):                prev = temp                temp = temp.right        if (prev.val > key):            prev.left = node        else:            prev.right = node     def inorder(self):        temp = self.root        stack = []        while (temp != None or not (len(stack) == 0)):            if (temp != None):                stack.append(temp)                temp = temp.left            else:                temp = stack.pop()                print(str(temp.val) + " ", end="")                temp = temp.right  if __name__ == "__main__":    GFG.main([])     # This code is contributed by rastogik346.

## C#

 using System;using System.Collections.Generic; public class GFG {    public static void Main(String[] args)    {        BST tree = new BST();        tree.insert(30);        tree.insert(50);        tree.insert(15);        tree.insert(20);        tree.insert(10);        tree.insert(40);        tree.insert(60);        tree.inorder();    }} public class Node {    public Node left;    public int val;    public Node right;     public Node(int val) { this.val = val; }} public class BST {    public Node root;     public void insert(int key)    {        Node node = new Node(key);        if (root == null) {            root = node;            return;        }        Node prev = null;        Node temp = root;        while (temp != null) {            if (temp.val > key) {                prev = temp;                temp = temp.left;            }            else if (temp.val < key) {                prev = temp;                temp = temp.right;            }        }        if (prev.val > key)            prev.left = node;        else            prev.right = node;    }     public void inorder()    {        Node temp = root;        Stack stack = new Stack();        while (temp != null || stack.Count != 0) {            if (temp != null) {                stack.Push(temp);                temp = temp.left;            }            else {                temp = stack.Pop();                Console.Write(temp.val + " ");                temp = temp.right;            }        }    }} // This code is contributed by Rajput-Ji

## Javascript

 // JS Code to insert node and to print inorder traversal// using iteration // BST Nodeclass Node {    constructor(val) {        this.val = val;        this.right = null        this.left = null    }}// Utility function to insert node in BSTfunction insert(root, key) {    let node = new Node(key);    if (!root) {        root = node;        return;    }    let prev = null;    let temp = root;    while (temp) {        if (temp.val > key) {            prev = temp;            temp = temp.left;        }        else if (temp.val < key) {            prev = temp;            temp = temp.right;        }    }    if (prev.val > key)        prev.left = node;    else        prev.right = node;}// Utiltiy function to print inorder traversalfunction inorder(root){    let temp = root;    let st=[];    while (temp != null || st.length!=0) {        if (temp != null) {            st.unshift(temp);            temp = temp.left;        }        else {            temp = st[0];            st.shift();            if(temp.val){                console.log(temp.val);            }            temp = temp.right;        }    }}  // Driver codelet root = new Node(null);insert(root, 30);insert(root, 50);insert(root, 15);insert(root, 20);insert(root, 10);insert(root, 40);insert(root, 60); inorder(root); // This code is contributed by adityamaharshi21

Output

10 15 20 30 40 50 60

Time Complexity: O(N)
Auxiliary Space: O(N)

Some Interesting Facts: