二进制 & |_元二进制搜索| 单边二元搜索

二进制 & |

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.

假设输入数组为[3、4、6、8、12、14、16] ，搜索键为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).

在最坏的情况下，它是最大索引(数组len-1 )中的位数。 因此，对于上面的示例，最大位数为3 (最大索引6为3位)。

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

让我们将位描述为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.

现在，我们的工作是根据应具有的值从左(MSB)到右(LSB)，0或1分配位。 现在我们将如何分配0或1，我们将进行讨论。

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.

首先，我们将尝试始终放置1，如果找到的当前索引具有更大的搜索键值，则将放置0，否则将放置1。如果找到的当前索引具有与键相同的值，则我们将完成。

So let's start with the example,

让我们从示例开始

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

要设置的^第一位是第0位MSB
首先将其设置为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

因此，当前索引为1X ₂ X ₃ ，其中X ₂ X ₃既不是0，也不是1(根本没有设置)。 因此，最小当前索引现在为100，即4(两个X ₂ X ₃中都输入0，这将导致最小索引)。 arr [4]为12，小于搜索关键字。 因此，在X1处放1很好

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

现在轮到第二位了。
首先设置1

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).

因此，我们有11X ₃ ，其中X ₃既不是0，也不是1(根本没有设置)。 因此，最小可能的当前索引现在为110(6)。 arr [6]为16，并且大于搜索关键字。 因此，我们不能将第1位设置为1。因此，我们需要将其设置为0。X ₂ = 0
现在轮到第二个位(LSB)了。

Let's set it with 1 first

首先设置1

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.

所以我们有101，所以当前索引现在是5(101)。 并且，arr [5] = 14。 我们找到了搜索关键字，它位于索引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).

这就是元二进制搜索的工作方式。 时间复杂度是代表最大索引的位数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.

   我们可能会在执行时发现任何目标索引，该目标索引大于最大可能索引。 假设数组的长度为25。然后，我们需要表示最大可能索引的位数-> 5。 因此，在处理时，我们可能需要处理比11111还要大的任何索引。 因此，我们需要检查这种情况。

2. Secondly, the searching key may not even exist, in that case, out of the loop, we will return -1 indicating not found.

   其次，搜索键甚至可能不存在，在这种情况下，循环外，我们将返回-1表示未找到。

元二进制搜索算法在C ++中的实现 (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

翻译自: https://www.includehelp.com/algorithms/meta-binary-search-one-sided-binary-search.aspx

二进制 & |