Count of elements that are binary searchable in the given array
Last Updated :
28 Dec, 2022
Given an array arr[] consisting of N integers, the task is to find the maximum count of integers that are binary searchable in the given array.
Examples:
Input: arr[] = {1, 3, 2}
Output: 2
Explanation: arr[0], arr[1] can be found.
Input: arr[] = {3, 2, 1, 10, 23, 22, 21}
Output: 3
Explanation: arr[1], arr[3], arr[5] can be found using binary search irrespective of whether the array is sorted or not.
Approach: The given problem can be solved by searching for each element separately in the array using the Binary Search approach and increment the count of those integers that exist in the array. Follow the below steps to solve the problem:
- Make a variable count = 0, that will store the count of elements that are binary searchable.
- For each element perform the binary search in the range [0, N) as:
- Initialize the variable l as 0 and r as N-1 and perform the binary search for arr[i].
- For each iteration of the while loop till l is less than equal to r, calculate the mid-value denoted by (l + r)/2.
- If arr[mid] equals arr[i] then increment count by 1.
- If arr[mid] is less than arr[i], then change l as mid + 1.
- Otherwise, change r as mid – 1.
- The final answer will be stored in the variable count.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
int totalBinarySearchable(vector< int > arr)
{
int count = 0;
int N = arr.size();
for ( int i = 0; i < N; i++) {
int l = 0, r = N - 1;
while (l <= r) {
int mid = (l + r) / 2;
if (arr[mid] == arr[i]) {
count++;
break ;
}
if (arr[mid] < arr[i]) {
l = mid + 1;
}
else {
r = mid - 1;
}
}
}
return count;
}
int main()
{
vector< int > arr = { 3, 2, 1, 10, 23, 22, 21 };
cout << totalBinarySearchable(arr);
return 0;
}
|
Java
import java.io.*;
class GFG {
static int totalBinarySearchable( int [] arr)
{
int count = 0 ;
int N = arr.length;
for ( int i = 0 ; i < N; i++) {
int l = 0 , r = N - 1 ;
while (l <= r) {
int mid = (l + r) / 2 ;
if (arr[mid] == arr[i]) {
count++;
break ;
}
if (arr[mid] < arr[i]) {
l = mid + 1 ;
}
else {
r = mid - 1 ;
}
}
}
return count;
}
public static void main(String[] args)
{
int [] arr = { 3 , 2 , 1 , 10 , 23 , 22 , 21 };
System.out.println(totalBinarySearchable(arr));
}
}
|
Python3
def totalBinarySearchable(arr):
count = 0
N = len (arr)
for i in range ( 0 , N):
l = 0
r = N - 1
while (l < = r):
mid = (l + r) / / 2
if (arr[mid] = = arr[i]):
count + = 1
break
if (arr[mid] < arr[i]):
l = mid + 1
else :
r = mid - 1
return count
if __name__ = = "__main__" :
arr = [ 3 , 2 , 1 , 10 ,
23 , 22 , 21 ]
print (totalBinarySearchable(arr))
|
C#
using System;
public class GFG {
static int totalBinarySearchable( int [] arr)
{
int count = 0;
int N = arr.Length;
for ( int i = 0; i < N; i++) {
int l = 0, r = N - 1;
while (l <= r) {
int mid = (l + r) / 2;
if (arr[mid] == arr[i]) {
count++;
break ;
}
if (arr[mid] < arr[i]) {
l = mid + 1;
}
else {
r = mid - 1;
}
}
}
return count;
}
public static void Main( string [] args)
{
int [] arr = { 3, 2, 1, 10, 23, 22, 21 };
Console.WriteLine(totalBinarySearchable(arr));
}
}
|
Javascript
<script>
function totalBinarySearchable(arr)
{
let count = 0;
let N = arr.length;
for (let i = 0; i < N; i++)
{
let l = 0,
r = N - 1;
while (l <= r) {
let mid = Math.floor((l + r) / 2);
if (arr[mid] == arr[i]) {
count++;
break ;
}
if (arr[mid] < arr[i]) {
l = mid + 1;
} else {
r = mid - 1;
}
}
}
return count;
}
let arr = [3, 2, 1, 10, 23, 22, 21];
document.write(totalBinarySearchable(arr));
</script>
|
Time Complexity: O(N*log(N))
Auxiliary Space: O(1)
Approach 2: This problem can also be solved in linear time complexity.
In the previous approach, we were checking if for all a[i] belonging to array a, it was binary searchable or not. The problem with this approach is that we were visiting some of the elements multiple times to check ordering conditions. Rather than doing, this while we are visiting a node, we can mark it as binary searchable or not binary searchable. When constructing a binary tree for the array, it should be noted that the traversal is towards the right, when the target element is greater than the root or towards the left, when the target element is smaller than the root element. Now, given a path, the target element should be greater than the maximum of all root nodes via which the path of searching deviated towards the right, and smaller than the minimum of all values via which the path deviated towards the left.
To better understand this, create a tree representation of the process of binary search on the array. For eg:
Conversion of the given array to Binary Search Tree
In the binary search technique, the root node is actually the middle element of all the elements in that subtree. For eg:
Node 5 is the middle element of array [2, 3, 1, 5, 8, 7, 9]
and Node 3 is the middle element of array [2, 3, 1]
Example:
Now, Let’s search for node 1 in the above array. So, target = 1
Initially, In Binary Search: left = 0, right = 6.
arr[] = {2, 3, 1, 5, 8, 7, 9}
First Iteration: middle = (left + right) / 2 = 3 (arr[3] = 5)
Comparing middle element with target.
Since 5 > 1, so, right = middle – 1 = 3 – 1 = 2.
arr[] = {2, 3, 1}
Second Iteration: middle = (0 + 2) / 2 = 1 (arr[1] = 3)
Comparing middle element with target.
Since 3 > 1, so right = middle – 1 = 1 – 1 = 0.
arr[] = {2}
Comparing middle element with target. The values don’t match.(arr[0]!=1)
Hence, 1 is not binary searchable.
The path needs to be traversed for node e to be binary searchable
In the above Figure, for node e to be binary searchable:
If we want to search e, then e must be greater than a and c because of BST (binary search tree) conventions. also, e must be smaller than b and d. If this is not the case, then e is not binary searchable.
So, we can summarise the condition as;
1. e < min(b, d)
2. e > max(a, c)
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
int countBinarySearchableIndex( int Arr[], int l, int r,
int LR, int RL)
{
if (l > r)
return 0;
int ans = 0;
int m = (l + r) / 2;
if (LR < Arr[m] && Arr[m] < RL)
ans = 1;
int l_ans = countBinarySearchableIndex(
Arr, l, m - 1, LR, min(RL, Arr[m]));
int r_ans = countBinarySearchableIndex(
Arr, m + 1, r, max(LR, Arr[m]), RL);
return ans + l_ans + r_ans;
}
int main()
{
int Arr[] = { 10, 1, 2, 3, 4, 8, 6, 5,
7, 12, 9, 8, 13, 15, 11 };
int n = 15;
cout << "Number of Binary Searchable Indexes: " ;
cout << countBinarySearchableIndex(Arr, 0, n - 1, -1e9,
1e9)
<< endl;
return 0;
}
|
Java
import java.io.*;
class GFG {
static int countBinarySearchableIndex( int [] Arr, int l,
int r, int LR,
int RL)
{
if (l > r)
return 0 ;
int ans = 0 ;
int m = (l + r) / 2 ;
if (LR < Arr[m] && Arr[m] < RL)
ans = 1 ;
int l_ans = countBinarySearchableIndex(
Arr, l, m - 1 , LR, Math.min(RL, Arr[m]));
int r_ans = countBinarySearchableIndex(
Arr, m + 1 , r, Math.max(LR, Arr[m]), RL);
return ans + l_ans + r_ans;
}
public static void main(String[] args)
{
int [] Arr = { 10 , 1 , 2 , 3 , 4 , 8 , 6 , 5 ,
7 , 12 , 9 , 8 , 13 , 15 , 11 };
int n = 15 ;
System.out.print(
"Number of Binary Searchable Indexes: " );
System.out.println(countBinarySearchableIndex(
Arr, 0 , n - 1 , ( int )-1e9, ( int )1e9));
}
}
|
Python3
def countBinarySearchableIndex(Arr, l, r, LR, RL):
if l > r:
return 0
ans = 0
m = (l + r) / / 2
if LR < Arr[m] and Arr[m] < RL:
ans = 1
l_ans = countBinarySearchableIndex(
Arr, l, m - 1 , LR, min (RL, Arr[m]))
r_ans = countBinarySearchableIndex(
Arr, m + 1 , r, max (LR, Arr[m]), RL)
return ans + l_ans + r_ans
Arr = [ 10 , 1 , 2 , 3 , 4 , 8 , 6 , 5 , 7 , 12 , 9 , 8 , 13 , 15 , 11 ]
n = 15
print ( "Number of Binary Searchable Indexes: " , end = "")
print (countBinarySearchableIndex(Arr, 0 , n - 1 , - 1e9 , 1e9 ))
|
C#
using System;
public class GFG {
static int countBinarySearchableIndex( int [] Arr, int l,
int r, int LR,
int RL)
{
if (l > r)
return 0;
int ans = 0;
int m = (l + r) / 2;
if (LR < Arr[m] && Arr[m] < RL)
ans = 1;
int l_ans = countBinarySearchableIndex(
Arr, l, m - 1, LR, Math.Min(RL, Arr[m]));
int r_ans = countBinarySearchableIndex(
Arr, m + 1, r, Math.Max(LR, Arr[m]), RL);
return ans + l_ans + r_ans;
}
static public void Main()
{
int [] Arr = { 10, 1, 2, 3, 4, 8, 6, 5,
7, 12, 9, 8, 13, 15, 11 };
int n = 15;
Console.Write(
"Number of Binary Searchable Indexes: " );
Console.WriteLine(countBinarySearchableIndex(
Arr, 0, n - 1, ( int )-1e9, ( int )1e9));
}
}
|
Javascript
function countBinarySearchableIndex(Arr, l, r, LR, RL)
{
if (l > r)
return 0;
let ans = 0;
let m = (l + r) / 2;
if (LR < Arr[m] && Arr[m] < RL)
ans = 1;
let l_ans = countBinarySearchableIndex(
Arr, l, m - 1, LR, Math.min(RL, Arr[m]));
let r_ans = countBinarySearchableIndex(
Arr, m + 1, r, Math.max(LR, Arr[m]), RL);
return ans + l_ans + r_ans;
}
let Arr = [ 10, 1, 2, 3, 4, 8, 6, 5,
7, 12, 9, 8, 13, 15, 11 ];
let n = 15;
console.log( "Number of Binary Searchable Indexes: " +
countBinarySearchableIndex(Arr, 0, n - 1, -1e9,
1e9));
|
Output
Number of Binary Searchable Indexes: 9
Time Complexity: O(n)
Auxiliary Space: O(log n) taken by Recursion Stack
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...