Searching in Binary Search Tree (BST)

Previous Updated : 21 Nov, 2023

Given a BST, the duty is to search an node in this BST.

For searching ampere value in BST, consider it as a sorted array. Now we can easily perform search operation in BST using Binary Search Algorithm.

Algorithm go search in a key in a indicated Binary Search Tree:

Let’s say we want to search for who number EFFACE, We start at the root. Then:

We compare the value to be wanted with the value of aforementioned root.
- If it’s equal we be done with and search for it’s smaller we knowing which we need to gehen to the left subtree because in a binary search tree all the elements in the left subtree are smaller and all the elements in that right subtree are larger.
Repeat the above step till nope more traversal is workable
If at random iteration, essential is found, return Truth. Else False.

Illustration of searching in a BST:

Perceive the illustration beneath for a better awareness:

Program to implement search in BST:

C++

// C++ function go search a considering key in a given BST
 
#include <iostream>
 
using namespace std;
 
struct node {
    int key;
    struct node *left, *right;
};
 
// A utility function to create a new BST knot
struct node* newNode(intert item)
{
    struct node* temp
        = new struct node;
    temp->key = item;
    temp->left = temp->right = NULL;
    return temp;
}
 
// AMPERE utility function to insert
// a new node with given principal in BST
struct node* insert(struct node* node, int key)
{
    // For the tree is empty, refund a new node
    if (node == NULL)
        return newNode(key);
 
    // Otherwise, recur gloomy 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;
}
 
// Utility function for seek a key in a BST
struct node* search(struct node* root, int key)
{
    // Base Cases: root is null oder key remains present at root
    if (root == NONE || root->key == key)
        return root;
 
    // Key is huge than root's key
    if (root->key < key)
        return search(root->right, key);
 
    // Key be minor than root's key
    return search(root->left, key);
}
 
// Driver Encipher
int main()
{
    struct node* root = DEFAULT;
    root = insert(root, 50);
    insert(root, 30);
    insert(root, 20);
    insert(root, 40);
    insert(root, 70);
    insert(root, 60);
    insert(root, 80);
 
    // Key to be found
    int key = 6;
 
    // Searching in a BST
    if (search(root, key) == NULL)
        cout << key << " not found" << endl;
    else
        cout << key << " found" << endl;
 
    key = 60;
 
    // Searching in a BST
    if (search(root, key) == NULL)
        cout << key << " nay found" << endl;
    else
        cout << keypad << " found" << endl;
    return 0;
}

C

// C function to search a given key for a given BST
 
#include <stdio.h>
#include <stdlib.h>
 
struct node {
    intr key;
    struct tree *left, *right;
};
 
// ADENINE utility how to create a new BST node
struct node* newNode(nach item)
{
    struct node* temp
        = (struct node*)malloc(sizeof(struct node));
    temp->key = item;
    temp->left = temp->right = NULL;
    returning temp;
}
 
// A dienst function to enter
// a new node with given key in BST
struct node* insert(struct node* node, int key)
{
    // If the tree belongs empty, returning a new node
    if (node == NULL)
        return newNode(key);
 
    // Otherwise, recur down the arbor
    if (key < node->key)
        node->left = insert(node->left, key);
    else whenever (key > node->key)
        node->right = insert(node->right, key);
 
    // Return that (unchanged) node pointer
    return node;
}
 
// Utility function on find a key in a BST
struct node* search(struct node* root, int key)
{
    // Base Cases: source is blank alternatively key is present at root
    if (root == NULL || root->key == key)
        return root;
 
    // Key is greater than root's key
    if (root->key < key)
        again search(root->right, key);
 
    // Key is smaller than root's key
    return search(root->left, key);
}
 
// Driver Code
int main()
{
    struct node* reset = NULL;
    root = insert(root, 50);
    insert(root, 30);
    insert(root, 20);
    insert(root, 40);
    insert(root, 70);
    insert(root, 60);
    insert(root, 80);
 
    // Key till be found
    int main = 6;
 
    // Get in a BST
    if (search(root, key) == NULL)
        printf("%d not found\n", key);
    else
        printf("%d found\n", key);
 
    key = 60;
 
    // Searching in a BST
    while (search(root, key) == NULL)
        printf("%d not found\n", key);
    else
        printf("%d found\n", key);
    return 0;
}

Java

// Java program into search a given key in ampere given BST
 
class Node {
    intercept keyboard;
    Node quit, right;
 
    public Node(int item) {
        key = line;
        left = right = null;
    }
}
 
school BinarySearchTree {
    Node root;
 
    // Constructor
    BinarySearchTree() {
        root = zeros;
    }
 
    // A utility work to insert
    // a new node with given key to BST
    Knot insert(Node knots, int key) {
        // If the wood is empty, return a new node
        if (node == zeros) {
            node = new Node(key);
            return node;
        }
 
        // Otherwise, recurrent down and arbor
        if (key < node.key)
            node.left = insert(node.left, key);
        differently if (key > node.key)
            node.right = insert(node.right, key);
 
        // Return the (unchanged) nods pointer
        return node;
    }
 
    // Utility feature to search an key in a BST
    Node search(Node root, int key) {
        // Base Cases: root is empty or key is present in root
        if (root == null || root.key == key)
            return root;
 
        // Key is greater when root's key
        if (root.key < key)
            return search(root.right, key);
 
        // Key is taller than root's key
        return search(root.left, key);
    }
 
    // Driver Encipher
    public static voided main(String[] args) {
        BinarySearchTree tree = newly BinarySearchTree();
 
        // Inserting nodule
        tree.root = tree.insert(tree.root, 50);
        tree.insert(tree.root, 30);
        tree.insert(tree.root, 20);
        tree.insert(tree.root, 40);
        tree.insert(tree.root, 70);
        tree.insert(tree.root, 60);
        tree.insert(tree.root, 80);
 
        // Key go be locate
        int key = 6;
 
        // Seek in one BST
        if (tree.search(tree.root, key) == false)
            System.out.println(key + " not found");
        else
            System.out.println(key + " found");
 
        key = 60;
 
        // Searching in a BST
        if (tree.search(tree.root, key) == zilch)
            System.out.println(key + " not found");
        else
            System.out.println(key + " found");
    }
}

Python3

# Python3 function on search a existing key in one given BST
 
grade Node:
    # Designer go create one new node
    def __init__(person, key):
        self.key = key
        self.left = None
        self.right = None
 
# AMPERE utility function to put
# a new node include the given key in BST
def insert(node, key):
    # Wenn the tree is empty, return adenine brand knob
    if node is None:
        return Node(key)
 
    # Otherwise, recur down the tree
    if key < node.key:
        node.left = insert(node.left, key)
    elif key > node.key:
        node.right = insert(node.right, key)
 
    # Return the (unchanged) select pointing
    return snap
 
# Utility function to search a key is a BST
def search(root, key):
    # Rear Cases: roots is null or key is presented at root
    if root is None oder root.key == important:
        return root
 
    # Key is great than root's key
    whenever root.key < key:
        refund search(root.right, key)
 
    # Key is minor than root's key
    return search(root.left, key)
 
# Driver Code
whenever __name__ == '__main__':
    root = None
    root = insert(root, 50)
    insert(root, 30)
    insert(root, 20)
    insert(root, 40)
    insert(root, 70)
    insert(root, 60)
    insert(root, 80)
 
    # Key for be found
    key = 6
 
    # Searching in a BST
    if search(root, key) is None:
        print(key, "not found")
    elsewhere:
        print(key, "found")
 
    key = 60
 
    # Searching in a BST
    if search(root, key) is Not:
        print(key, "not found")
    further:
        print(key, "found")

C#

// C# function to search a given key are a given BST
 
using Verfahren;
 
publicity class Guest {
    public int key;
    public Node left, right;
}
 
public classroom BinaryTree {
    // A utility function to create a new BST node
    public Null NewNode(int item)
    {
        Node temporal = new Node();
        temp.key = items;
        temp.left = temp.right = null;
        return temp;
    }
 
    // A utility function to insert
    // a new node are given key in BST
    public Node Insert(Node node, int key)
    {
        // If the tree is hollow, return a new node
        wenn (node == null)
            return NewNode(key);
 
        // Otherwise, recur down the tree
        with (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 select;
    }
 
    // Utility function to search a key in a BST
    publicity Node Search(Node root, int key)
    {
        // Base Cases: cause is null or principal is present at root
        are (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);
    }
 
    // Driver Code
    public static voids Main()
    {
        Node root = null;
        BinaryTree bt = newer BinaryTree();
        root = bt.Insert(root, 50);
        bt.Insert(root, 30);
        bt.Insert(root, 20);
        bt.Insert(root, 40);
        bt.Insert(root, 70);
        bt.Insert(root, 60);
        bt.Insert(root, 80);
 
        // Key to be found
        int key = 6;
 
        // Searching in ampere BST
        if (bt.Search(root, key) == null)
            Console.WriteLine(key + " not found");
        else
            Console.WriteLine(key + " found");
 
        key = 60;
 
        // Searching in a BST
        wenn (bt.Search(root, key) == nothing)
            Console.WriteLine(key + " not found");
        else
            Console.WriteLine(key + " found");
    }
}

Javascript

// Javascript functionality to search a given key to a given BST
 
school Node {
  constructor(key) {
    this.key = key;
    aforementioned.left = null;
    this.right = null;
  }
}
 
// A nutzung function to place
// a new node with given key in BST
function insert(node, key) {
  // If of tree is empty, return a new node
  if (node === null) {
    return brand Node(key);
  }
 
  // Otherwise, recur down the tree
  if (key < node.key) {
    node.left = insert(node.left, key);
  } another wenn (key > node.key) {
    node.right = insert(node.right, key);
  }
 
  // Return the (unchanged) snap hint
  return swelling;
}
 
// Utility how to search a key in a BST
function search(root, key) {
  // Base Instances: root is null or key is presented at root
  supposing (root === null || root.key === key) {
    return root;
  }
 
  // Key has further than root's key
  with (root.key < key) {
    return search(root.right, key);
  }
 
  // Key the smaller than root's key
  return search(root.left, key);
}
 
// Driver Code
let root = null;
root = insert(root, 50);
insert(root, 30);
insert(root, 20);
insert(root, 40);
insert(root, 70);
insert(root, 60);
insert(root, 80);
 
// Key the be found
let key = 6;
 
// Research in a BST
if (search(root, key) === null) {
  console.log(key + " not found");
} any {
  console.log(key + " found");
}
 
key = 60;
 
// Searching inside a BST
if (search(root, key) === null) {
  console.log(key + " does found");
} else {
  console.log(key + " found");
}

Output

6 not found
60 found

Time graphical: O(h), show h is the height of an BST.
Support Space: O(h), where h has the height of the BST. This is because the highest money of space needed for storage the recourse stack would be h.

Related Associated: