Home » Algorithms

Meta Binary Search | One-sided Binary Search

Meta Binary Search: In this tutorial, we will learn about meta binary search, its example, and its implementation using C++. By Radib Kar Last updated : August 14, 2023

What is Meta Binary Search?

Meta Binary Search is a modified version of binary search where we use bit manipulation. It is also known as a one-sided Binary Search. In other words, Meta Binary Search is a one-sided binary search where we work on the index using bit manipulation. We are to find the target index by using bit manipulation like the below example where the algorithm is explained.

Meta Binary Search Example

Say the input array is [3, 4, 6, 8, 12, 14, 16] and searching key says 14.

The idea is to figure out the target index. And we will do that using bit manipulation and thus we will use the bit representation of the index. On each iteration, we will set the bits.

Now the question is, how many bits can be there at maximum in the target index?

Taking the worst case, it's the number of bits in the maximum index (array len-1). So for the above example, the maximum number of bits is 3 (max index 6 has 3 bits).

Let's describe the bits as x₁x₂x₃

Now our work is to assign bits from left (MSB) to the right (LSB), 0, or 1 based on the values they should have. Now how would we assign 0 or 1, we will discuss now.

First, we will try to put 1 always, if the current index found has value greater searching key then we will put 0, otherwise it's fine to put 1. If we find the current index found has the same value as the key then we are done.

So let's start with the example,

The first bit to be set is the 0^th bit, MSB
First set it as 1

So the current index is 1X₂X₃ where X₂X₃ is not either 0, not 1(not set at all). So the minimum current index is right now 100 which is 4(putting 0 in both X₂X₃ which will lead to minimum index). arr[4] is 12 and it's less than the searching key. Thus it's fine to put 1 at X1

Now it's turn for the second bit.
Let's set it with 1 first

So we have 11X₃, where X₃ is not either 0, not 1(not set at all). So the minimum possible current index is right now 110(6). arr[6] is 16 and it's greater than the searching key. Thus we can't set 1st bit as 1. So we need to set that as 0. X₂ =0
Now it's turn for the 2nd bit(LSB).

Let's set it with 1 first

So we have 101, So the current index is right now 5(101). And, arr[5]=14. We found the searching key and it's at index 5.

This is how Meta Binary Search works. The time complexity is the number of bits to represent the maximum index which is Log(n).

Meta Binary Search Types of Edge Cases

During the execution of the algorithm, we found that there can be two types of edge cases:

1. We may find any target index while executing which is more than the maximum possible index. Say for example the, length of array is 25. Then, the number of bits we need to represent the maximum index possible->5. So while processing we may need to process any index like 11111 which is more than the maximum index possible. Thus we need to keep a check for this kind of scenario.
2. Secondly, the searching key may not even exist, in that case, out of the loop, we will return -1 indicating not found.

C++ program to implement meta binary search algorithm

#include <bits/stdc++.h>
using namespace std;

int logn(int n)
{
    int count = 0;
    while (n) {
        count++;
        n >>= 1;
    }
    return count;
}

int meta_binary_search(vector<int> arr, int key)
{
    int n = arr.size();
    int no_of_bits = logn(n - 1);

    int cur_index = 0;
    //iterating log(n) time
    for (int shift = no_of_bits - 1; shift >= 0; shift--) {
        //set current bit as 1
        int new_cur_index = cur_index + 1 << shift;

        if (new_cur_index >= n) {
            //can't set bit as 1
        }
        else {
            if (arr[new_cur_index] == key)
                return new_cur_index;
            //we can set bit as 1
            else if (arr[new_cur_index] < key) { 
                cur_index = new_cur_index;
            }
        }
    }

    //not found
    return -1;
}

int main()
{
    vector<int> arr{ 3, 4, 6, 8, 12, 14, 16 };

    int key = 12;

    //key found case
    int index = meta_binary_search(arr, key);
    if (index != -1)
        cout << "key " << key << " found at: " << index << endl;
    else
        cout << "key " << key << " not found\n";

    //key not found case
    key = 9;
    index = meta_binary_search(arr, key);
    if (index != -1)
        cout << "key " << key << " found at: " << index << endl;
    else
        cout << "key " << key << " not found\n";

    return 0;
}

Output:

key 12 found at: 4
key 9 not found