Algorithm for finding minimum or maximum element in Binary Search Tree【O(log V) / O(V)】

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.

Below is the Example of Binary Search Tree.

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

Algorithm for finding minimum or maximum element in Binary Search Tree

As we know the Property of Binary search tree.This quite simple

Approch for finding minimum element:

  • Traverse the node from root to left recursively until left is NULL.
  • The node whose left is NULL is the node with minimum value.

Approch for finding maximum element:

  • Traverse the node from root to right recursively until right is NULL.
  • The node whose right is NULL is the node with maximum value.

Implementation of the above approches.

// C++ program to find maximum or minimum element in binary search tree 
#include <bits/stdc++.h>  
using namespace std; 
   
struct node 
{ 
    int key; 
    struct node *left, *right; 
}; 
   
// A utility function to create a new BST node 
struct 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 insert a new node with given key in BST */
struct node* insert(struct node* node, int key) 
{ 
    struct node *newNode(int );
    /* 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; 
} 
/* Given a non-empty binary search tree,  
return the minimum data value found in that  
tree. Note that the entire tree does not need  
to be searched. */
int minValue(struct node* node)  
{  
    struct node* current = node;  
    /* loop down to find the leftmost leaf */
    while (current->left != NULL)  
    {  
        current = current->left;  
    }  
    return(current->key);  
}  
/* Given a non-empty binary search tree,  
return the maximum data value found in that  
tree. Note that the entire tree does not need  
to be searched. */
int maxValue(struct node* node)  
{  
    struct node* current = node;  
    /* loop down to find the leftmost leaf */
    while (current->right != NULL)  
    {  
        current = current->right;  
    }  
    return(current->key);  
}  
// Driver Program to test above functions 
int main() 
{ 
    int maxValue(struct node* );
    struct node* insert(struct node* , int );
    int minValue(struct node* ); 
    struct node *root = NULL; 
    root = insert(root, 8); 
    insert(root, 3); 
    insert(root, 10); 
    insert(root, 1); 
    insert(root, 6); 
    insert(root, 4); 
    insert(root, 7); 
    insert(root, 5);
    insert(root, 10);
    insert(root, 9);
    insert(root, 13);
    insert(root, 11);
    insert(root, 14);
    insert(root, 12);
    insert(root, 2);
    
    cout << "\n Minimum value in BST is " << minValue(root)<<endl;  
    cout << "\n Maximum value in BST is " << maxValue(root);  
    return 0; 
} 

Output:

Minimum value in BST is 1
Maximum value in BST is 14

Explanation:

For Finding Minimum value in Binary search tree.

Time Complexity:

O(N) Worst case happens for left skewed trees in finding the minimum value. O(N) Worst case happens for right skewed trees in finding the maximum value.

O(1) Best case happens for left skewed trees in finding the maximum value. O(1) Best case happens for right skewed trees in finding the minimum value.

In the balanced Binary Search tree, the time complexity is O(log N)

N is the number of elements in a Binary Search tree


This is a companion discussion topic for the original entry at http://iq.opengenus.org/find-maximum-or-minimum-element-in-binary-search-tree/