Number of elements smaller than root using preorder traversal of a BST
Last Updated :
30 Aug, 2022
Given a preorder traversal of a BST. The task is to find the number of elements less than root.
Examples:
Input: preorder[] = {3, 2, 1, 0, 5, 4, 6}
Output: 3
Input: preorder[] = {5, 4, 3, 2, 1}
Output: 4
For a binary search tree, a preorder traversal is of the form:
root, { elements in left subtree of root }, { elements in right subtree of root }
Simple approach:
- Traverse the given preorder.
- Check if the current element is greater than root.
- If yes then return the indexOfCurrentElement – 1 as the no. elements smaller than root will be all the elements that occurs before the currentelement except root.
Implementation:
C++
#include <iostream>
using namespace std;
int findLargestIndex( int arr[], int n)
{
int i, root = arr[0];
for (i = 0; i < n-1; i++)
{
if (arr[i] > root)
return i-1;
}
}
int main()
{
int preorder[] = {3, 2, 1, 0, 5, 4, 6};
int n = sizeof (preorder) / sizeof (preorder[0]);
cout << findLargestIndex(preorder, n);
return 0;
}
|
Java
class GFG
{
static int findLargestIndex( int arr[],
int n)
{
int i, root = arr[ 0 ];
for (i = 0 ; i < n - 1 ; i++)
{
if (arr[i] > root)
return i- 1 ;
}
return 0 ;
}
public static void main(String ags[])
{
int preorder[] = { 3 , 2 , 1 , 0 , 5 , 4 , 6 };
int n = preorder.length;
System.out.println(findLargestIndex(preorder, n));
}
}
|
Python3
def findLargestIndex(arr, n):
i, root = arr[ 0 ], arr[ 0 ];
for i in range ( 0 , n - 1 ):
if (arr[i] > root):
return i - 1 ;
preorder = [ 3 , 2 , 1 , 0 , 5 , 4 , 6 ];
n = len (preorder)
print (findLargestIndex(preorder, n));
|
C#
using System;
class GFG
{
static int findLargestIndex( int []arr,
int n)
{
int i, root = arr[0];
for (i = 0; i < n - 1; i++)
{
if (arr[i] > root)
return i - 1;
}
return 0;
}
static public void Main()
{
int []preorder = {3, 2, 1, 0, 5, 4, 6};
int n = preorder.Length;
Console.WriteLine(findLargestIndex(preorder, n));
}
}
|
PHP
<?php
function findLargestIndex( $arr , $n )
{
$i ; $root = $arr [0];
for ( $i = 0; $i < $n - 1; $i ++)
{
if ( $arr [ $i ] > $root )
return $i - 1;
}
}
$preorder = array (3, 2, 1, 0, 5, 4, 6);
$n = count ( $preorder );
echo findLargestIndex( $preorder , $n );
?>
|
Javascript
<script>
function findLargestIndex(arr, n)
{
var i, root = arr[0];
for (i = 0; i < n-1; i++)
{
if (arr[i] > root)
return i-1;
}
}
var preorder = [3, 2, 1, 0, 5, 4, 6];
var n = preorder.length;
document.write( findLargestIndex(preorder, n));
</script>
|
Time complexity: O(n)
Efficient approach (Using Binary Search): Here the idea is to make use of an extended form of binary search.
The steps are as follows:
- Go to mid. Check if the element at mid is greater than root. If yes then we recurse on the left half of array.
- Else if the element at mid is lesser than root and element at mid+1 is greater than root we return mid as our answer.
- Else we recurse on the right half of array to repeat the above steps.
Below is the implementation of the above idea.
C++
#include <bits/stdc++.h>
using namespace std;
int findLargestIndex( int arr[], int n)
{
int root = arr[0], lb = 0, ub = n-1;
while (lb < ub)
{
int mid = (lb + ub)/2;
if (arr[mid] > root)
ub = mid - 1;
else
{
if (arr[mid + 1] > root)
return mid;
else lb = mid + 1;
}
}
return lb;
}
int main()
{
int preorder[] = {3, 2, 1, 0, 5, 4, 6};
int n = sizeof (preorder) / sizeof (preorder[0]);
cout << findLargestIndex(preorder, n);
return 0;
}
|
Java
import java.util.*;
class GFG
{
static int findLargestIndex( int arr[],
int n)
{
int root = arr[ 0 ],
lb = 0 , ub = n - 1 ;
while (lb < ub)
{
int mid = (lb + ub) / 2 ;
if (arr[mid] > root)
ub = mid - 1 ;
else
{
if (arr[mid + 1 ] > root)
return mid;
else lb = mid + 1 ;
}
}
return lb;
}
public static void main(String args[])
{
int preorder[] = { 3 , 2 , 1 , 0 , 5 , 4 , 6 };
int n = preorder.length;
System.out.println(
findLargestIndex(preorder, n));
}
}
|
Python3
def findLargestIndex(arr, n):
root = arr[ 0 ];
lb = 0 ;
ub = n - 1 ;
while (lb < ub):
mid = (lb + ub) / / 2 ;
if (arr[mid] > root):
ub = mid - 1 ;
else :
if (arr[mid + 1 ] > root):
return mid;
else :
lb = mid + 1 ;
return lb;
preorder = [ 3 , 2 , 1 , 0 , 5 , 4 , 6 ];
n = len (preorder);
print (findLargestIndex(preorder, n));
|
C#
using System;
class GFG
{
static int findLargestIndex( int []arr,
int n)
{
int root = arr[0],
lb = 0, ub = n - 1;
while (lb < ub)
{
int mid = (lb + ub) / 2;
if (arr[mid] > root)
ub = mid - 1;
else
{
if (arr[mid + 1] > root)
return mid;
else lb = mid + 1;
}
}
return lb;
}
public static void Main(String []args)
{
int []preorder = {3, 2, 1, 0, 5, 4, 6};
int n = preorder.Length;
Console.WriteLine(
findLargestIndex(preorder, n));
}
}
|
PHP
<?php
function findLargestIndex( $arr , $n )
{
$root = $arr [0];
$lb = 0;
$ub = $n - 1;
while ( $lb < $ub )
{
$mid = (int)(( $lb + $ub ) / 2);
if ( $arr [ $mid ] > $root )
$ub = $mid - 1;
else
{
if ( $arr [ $mid + 1] > $root )
return $mid ;
else
$lb = $mid + 1;
}
}
return $lb ;
}
$preorder = array (3, 2, 1, 0, 5, 4, 6);
$n = count ( $preorder );
echo findLargestIndex( $preorder , $n );
?>
|
Javascript
<script>
function findLargestIndex(arr, n)
{
var root = arr[0], lb = 0, ub = n-1;
while (lb < ub)
{
var mid = parseInt((lb + ub)/2);
if (arr[mid] > root)
ub = mid - 1;
else
{
if (arr[mid + 1] > root)
return mid;
else lb = mid + 1;
}
}
return lb;
}
var preorder = [3, 2, 1, 0, 5, 4, 6];
var n = preorder.length;
document.write( findLargestIndex(preorder, n));
</script>
|
Time Complexity: O(logn)
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...