通过位掩码进行二进制搜索？

Question

我已经多次使用此算法对Ints 或Longs 进行二分搜索。基本上，我从Long.MinValue 和Long.MaxValue 开始，并决定根据我最大化（或最小化）的函数的值将位设置在ith 位置。在实践中，这被证明更快（确切地说是 63*2 位运算）并且更容易编码，并且避免了许多 gotchas of traditional binary search implementations。

这是我在 Scala 中的算法：

/**
 * @return Some(x) such that x is the largest number for which f(x) is true
 *         If no such x is found, return None
 */
def bitBinSearch(f: Long => Boolean): Option[Long] = {
  var n = 1L << 63
  var p = 0L
  for (i <- 62 to 0 by -1) {
    val t = 1L << i
    if (f(n + t)) n += t
    if (f(p + t)) p += t
  }
  if (f(p)) Some(p) else if (f(n)) Some(n) else None
}

我有 3 个问题：

• 这个算法在文献中叫什么？当然，我不能成为这个的发明者 - 但是，当我尝试谷歌搜索二进制搜索+位掩码/切换的各种组合时，我没有找到任何东西。我个人一直称它为“bitBinSearch”。我完全没有看到在对 Int 或 Long 域进行二进制搜索的文章中提到这一点，而这将是微不足道的。

• 无论如何都可以改进/缩短代码吗？现在我在n 和p 中跟踪消极和积极的解决方案。有什么聪明的方法可以将它们合并为单个变量吗？以下是一些示例测试用例：http://scalafiddle.net/console/70a3e3e59bc61c8eb7acfbba1073980c 在您尝试回答之前

• 是否有可以与Doubles 和Floats 一起使用的版本？

Answer 1

只要你在玩游戏（在某些圈子里是一种流行的消遣），为什么不一直玩下去呢？不知道有没有效率提升，但我觉得其实让算法更清晰一点。

def bitBinSearch(f: Long => Boolean): Option[Long] = {
  var n = Long.MinValue
  var p = 0L
  var t = n >>> 1
  while (t > 0) {
    if ( f(n|t) ) n |= t
    if ( f(p|t) ) p |= t
    t >>= 1
  }
  List(p,n).find(f)
}

当然，如果你使用递归，你可以消除那些讨厌的vars。

import scala.annotation.tailrec
@tailrec
def bitBinSearch( f: Long => Boolean
                , n: Long = Long.MinValue
                , p: Long = 0L
                , t: Long = Long.MinValue >>> 1 ): Option[Long] = {
  if (t > 0) bitBinSearch(f
                         , if (f(n|t)) n|t else n
                         , if (f(p|t)) p|t else p
                         , t >> 1
                         )
  else List(p,n).find(f)
}

同样，可能效率不高，但可能更像 Scala。

更新

您对 Int/Long 的评论让我想知道是否一个函数可以完成所有工作。

经过几个死胡同，我终于想出了这个（奇怪的是，实际上非常接近您的原始代码）。

import Integral.Implicits._
import Ordering.Implicits._
def bitBinSearch[I](f: I => Boolean)(implicit ev:Integral[I]): Option[I] = {
  def topBit(x: I = ev.one):I = if (x+x < ev.zero) x else topBit(x+x)
  var t:I = topBit()
  var p:I = ev.zero
  var n:I = t+t
  while (t > ev.zero) {
    if ( f(p+t) ) p += t
    if ( f(n+t) ) n += t
    t /= (ev.one+ev.one)
  }
  List(p,n).find(f)
}

这通过了以下测试。

assert(bitBinSearch[Byte] (_ <= 0) == Some(0))
assert(bitBinSearch[Byte] (_ <= 1) == Some(1))
assert(bitBinSearch[Byte] (_ <= -1) == Some(-1))
assert(bitBinSearch[Byte] (_ <= 100) == Some(100))
assert(bitBinSearch[Byte] (_ <= -100) == Some(-100))
assert(bitBinSearch[Short](_ <= 10000) == Some(10000))
assert(bitBinSearch[Short](_ <= -10000) == Some(-10000))
assert(bitBinSearch[Int]  (_ <= Int.MinValue) == Some(Int.MinValue))
assert(bitBinSearch[Int]  (_ <= Int.MaxValue) == Some(Int.MaxValue))
assert(bitBinSearch[Long] (_ <= Long.MinValue) == Some(Long.MinValue))
assert(bitBinSearch[Long] (_ <= Long.MaxValue) == Some(Long.MaxValue))
assert(bitBinSearch[Long] (_ < Long.MinValue) == None)

Answer 2

我不知道 Scala，但这是我在 java 中通过位掩码进行二进制搜索的版本
我的算法是这样的

我们从 2 的最高幂的索引开始，到 2⁰ 结束。每次看到
A[itemIndex] ≤ A[index]，我们都会更新 itemIndex += index
迭代后itemIndex 给出项目的索引（如果存在于数组中），否则给出 A 中的楼层值

int find(int[] A, int item) { // A uses 1 based indexing
    int index = 0;
    int N = A.length;
    for (int i = Integer.highestOneBit(N); i > 0; i >>= 1) {
        int j = index | i;
        if (j < N && A[j] <= item) {
            index = j;
            if (A[j] == item) break;
        }
    }
    return item == A[index] ? index : -1;
}