Meta Binary Search | One-sided Binary Search

In this article, we are going to see what is meta binary search and its implementation? This is a modified version of binary search where we use bit manipulation. It's also known as one-sided Binary Search.
Submitted by Radib Kar, on July 19, 2020

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.

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 x1x2x3

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 0th bit, MSB
First set it as 1

So the current index is 1X2X3 where X2X3 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 X2X3 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 11X3, where X3 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. X2 =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).

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.

Implementation of the meta binary search algorithm in C++

#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





Comments and Discussions

Ad: Are you a blogger? Join our Blogging forum.





Languages: » C » C++ » C++ STL » Java » Data Structure » C#.Net » Android » Kotlin » SQL
Web Technologies: » PHP » Python » JavaScript » CSS » Ajax » Node.js » Web programming/HTML
Solved programs: » C » C++ » DS » Java » C#
Aptitude que. & ans.: » C » C++ » Java » DBMS
Interview que. & ans.: » C » Embedded C » Java » SEO » HR
CS Subjects: » CS Basics » O.S. » Networks » DBMS » Embedded Systems » Cloud Computing
» Machine learning » CS Organizations » Linux » DOS
More: » Articles » Puzzles » News/Updates


© https://www.includehelp.com some rights reserved.