二分查找中的第一次出现

Question

我正在修改一些代码，然后我意识到了一些我从来不知道的事情。正常的二分搜索将在数据集中为多次出现的键返回随机索引。如何修改下面的代码以返回第一次出现？这是人们做的事情吗？

//ripped from the JDK
public static int binarySearchValue(InvertedContainer.InvertedIndex[] a, long key) {
    return bSearchVal(a, 0, a.length, key);
}

private static int bSearchVal(InvertedContainer.InvertedIndex[] a, int fromIndex,
                                 int toIndex, long key) {
    int low = fromIndex;
    int high = toIndex - 1;

    while (low <= high) {
        int mid = (low + high) >>> 1;
        long midVal = a[mid].val;

        if (midVal < key)
            low = mid + 1;
        else if (midVal > key)
            high = mid - 1;
        else
            return mid; // key found
    }
    return (low); // key not found. return insertion point
}

Answer 1

Jon Skeets 帖子的补充：

潜在更快的实现实际上并不难实现，只添加了 2 行代码，这是我的做法：

    if (midVal < key)
        low = mid + 1;
    else if (midVal > key)
        high = mid - 1;
    else if (low != mid) //Equal but range is not fully scanned
        high = mid; //Set upper bound to current number and rescan
    else //Equal and full range is scanned
        return mid;

Answer 2

找到一个匹配值后，你基本上需要遍历集合，直到找到一个不匹配的条目。

您可以潜在地通过立即获取低于您要查找的键的索引来使其更快，然后在两者之间进行二进制切割 - 但我可能会选择更简单的版本，这可能“足够高效”，除非您有大量相等的条目。

Answer 3

如果您的数据都是完整的，那么这个 hack 可以提供帮助。 它使用一个浮点数组来存储值。

float array[];    //contains all integral values
int searchValue;

int firstIndex = -(binarySearch(array, (float)searchValue - 0.5F) + 1);

基本上，它的作用是在您的搜索值和它之前的整数之间找到一个值的插入索引。由于所有值都是整数，因此它会查找搜索值的第一个匹配项。

这也是 log(n) 时间。

示例：

import java.util.Arrays;

public class BinarySearch {
    // considering array elements are integers
    float ar[] = new float[] { 1, 2, 3, 3, 4, 4, 5, 9, 9, 12, 12 };

    public void returnFirstOccurrence(int key) {
        int firstIndex = -(Arrays.binarySearch(ar, key - 0.5F) + 1);
        if (ar[firstIndex] != key)
            System.out.println("Key doesn't exist");
        else
            System.out.println("First index of key is " + firstIndex);
    }

    public static void main(String Args[]) throws Exception {
        new BinarySearch().returnFirstOccurrence(9);
    }

}

输出：7

p.s：我在几次编码比赛中都使用过这个技巧，而且每次都很好用。

Answer 4

您可以实现“下限”算法而不是二进制搜索。该算法用于例如在C++/STL 中，它的Java 成绩单很简单。下界的算法复杂度也是 O(log n) 作为二分查找。这比首先使用二分搜索和线性搜索第一个匹配元素要好 - 这将具有最坏情况的行为 O(n)。

Answer 5

您可以通过更清晰的匹配定义来调整现有的搜索算法。您可以看出序列 1,3,5,5,5,9 中突出显示的 5 是第一个，因为它之前的数字 (3) 小于 5。所以如果 mid 落在数组元素等于键，如果 a[mid-1] 小于键，则仅将其视为匹配项，其他相等的数组元素被视为大于元素。现在你的算法变成了（在包括 Jon Skeet 的建议为插入点返回负数之后）：

public static int binarySearch(int[] a, int key) {
    int low=0,high=a.length-1;
    while (low<=high) {
        int mid=(low+high) >>> 1;
        int midVal=a[mid];
        if (midVal < key) 
            low=mid+1;
        else if (mid>0 && a[mid-1]>=key) //we already know midval>=key here
            high=mid-1;
        else if (midVal==key) //found the 1st key 
             return mid;
        else
            return ~mid;      //found insertion point
    }
    return ~(a.length);       //insertion point after everything
}

它使用了更多的比较，但在我的基准测试中比 Stev314 的版本更快，这可能是因为缓存效应。

Answer 6

以下算法使用大于或等于您的搜索关键字的关键字对第一个项目进行二进制搜索...

while (upperbound > lowerbound)
{
  testpos = lowerbound + ((upperbound-lowerbound) / 2);

  if (item[testpos] >= goal)
  {
    //  new best-so-far
    upperbound = testpos;
  }
  else
  {
    lowerbound = testpos + 1;
  }
}

这不是为 Java 编写的，我对此不太了解，因此可能需要稍作调整。请注意，边界是半开的（下界包含在内，上界不包含在内），这对于正确性很重要。

这可以适应其他类似的搜索 - 例如找到最后一个键

这是我之前的问答here稍作修改。

Answer 7

这里是解决方案，我发现使用二分搜索在排序数组中获得多次出现的键的较低索引。

int lowerBound(int[] array,int fromIndex, int toIndex, int key)
{
    int low = fromIndex-1, high = toIndex;
    while (low+1 != high)
    {
        int mid = (low+high)>>>1;
        if (array[mid]< key) low=mid;
        else high=mid;
    }
    int p = high;
    if ( p >= toIndex || array[p] != key )
        p=-1;//no key found
    return p;
}

我们必须在此代码中稍作更改以使用二进制搜索来处理上限，所以这里是代码的工作副本。

 int upperBound(int[] array,int fromIndex, int toIndex, int key)
{
    int low = fromIndex-1, high = toIndex;
    while (low+1 != high)
    {
        int mid = (low+high)>>>1;
        if (array[mid]> key) high=mid;
        else low=mid;
    }
    int p = low;
    if ( p >= toIndex || array[p] != key )
        p=-1;//no key found
    return p;
}

Answer 8

一种方法是在整个二分搜索中保持一个不变量。在您的特定情况下，不变量将是：

• array[low] < key
• key <= array[high]

然后你可以使用二分搜索来最小化低和高之间的差距。当low + 1 == high，high 将是答案。 C++ 示例代码：

// check invariant on initial values.
if (array[low] >= key) return low;
if (array[high] < key) return high+1;
// low + 1 < high ensures high is at least low + 2, thus
// mid will always be different from low or high. It will
// stop when low + 1 == high.
while (low + 1 < high) {
  int mid = low + (high - low) / 2;
  if (array[mid] < key) {
    low = mid;   // invariant: array[low] < key
  } else {
    high = mid;  // invariant: array[high] >= key
  }
}
return high;

这与您的示例代码之间的主要区别是将low 和high 更新为仅mid 而不是mid+1 或mid-1，因为我们已经检查了array[mid] 的值，我们可以保证更新边界时，不变量仍然成立。在开始搜索之前，您还需要检查初始值的不变量。

Answer 9

在这个thread 中，您可以找到二分查找的完整示例（递归版本），以及其他两个版本（基于原始版本），它们可以让您获得第一个索引和给定键的最后一个索引。

为方便起见，我添加了相关的 Junit 测试。

Answer 10

这是 scala 中解决方案的一种变体。使用模式匹配和递归而不是 while 循环来获得第一次出现。

def binarySearch(arr:Array[Int],key:Int):Int = {
     def binSearchHelper(lo:Int,hi:Int,mid:Int):Int = {
        if(lo > hi) -1 else {
            if(arr(mid) == key) mid else if(arr(mid) > key){
                binSearchHelper(lo,mid-1,lo + (((mid-1) - lo)/2))
            }else{
                binSearchHelper(mid+1,hi,(mid+1) + ((hi - (mid+1))/2))
            }
        }
     }
    binSearchHelper(0,arr.size-1,(arr.size-1)/2)
}

def findFirstOccurrence(arr:Array[Int],key:Int):Int = {
    val startIdx = binarySearch(arr,key)
    startIdx match {
        case 0 => 0
        case -1 => -1
        case _ if startIdx > 0 => {
            if(arr(startIdx - 1) < key) startIdx else {
                    findFirstOccurrence(arr.slice(0,startIdx),key)
            }
        }
    }
}

Answer 11

这应该可以解决问题

private static int bSearchVal(InvertedContainer.InvertedIndex[] a, int fromIndex,
                             int toIndex, long key) {
int low = fromIndex;
int high = toIndex - 1;
int result = low;
while (low <= high) {
    int mid = (low + high) >>> 1;
    long midVal = a[mid].val;

    if (midVal < key)
        low = mid + 1;
    else if (midVal > key)
        high = mid - 1;
    else
    {
        result = mid;
        high = mid -1; 
    }
}
return result; 

}

Answer 12

对于元素的最后一次出现：

static int elementExists(int input[], int element){
    int lo=0;
    int high = input.length-1;
    while(lo<high){
        int mid = (lo + high )/2;
        if(element >input[mid] ){
            lo = mid+1;
        }
        else if(element < input[mid]){
            high= mid-1;
        }
        else if (high != input.length-1) //Change for the Occurrence check
            lo = mid;
        else {
            return mid;
        }
    }
    return -1;
}

第一次出现：

else if (lo != mid){
        high = mid;
}

Answer 13

我认为一种更简单的方法是将最新的mid 索引，其中xs[mid] == key 存储到结果变量中，然后继续运行二进制搜索。

这是快速代码：

func first<T: Comparable>(xs: [T], key: T) -> Int {
    var lo = xs.startIndex
    var hi = xs.endIndex - 1
    var res = -1
    while lo <= hi {
        let mid = lo + (hi - lo) >> 1
        if xs[mid] == key { hi = mid - 1; res = mid }
        else if xs[mid] < key { lo = mid + 1}
        else if xs[mid] > key { hi = mid - 1 }
    }

    return res
}

此外，如果您要找到键的最后一个索引，则需要进行非常小的更改（仅一行）。

func last<T: Comparable>(xs: [T], key: T) -> Int {
    var lo = xs.startIndex
    var hi = xs.endIndex - 1
    var res = -1
    while lo <= hi {
        let mid = lo + (hi - lo) >> 1
        if xs[mid] == key { lo = mid + 1;  res = mid }
        else if xs[mid] < key { lo = mid + 1}
        else if xs[mid] > key { hi = mid - 1 }
    }

    return res
}

Answer 14

试试这个 javascript 递归解决方案。从某种意义上说它是最优的，它是 O(log(N))

function solve(A, e) {
  function solve (A, start, end, e, bestUntilNow) {
    if (start > end) {
      if (A[start] === e)
        return start
      return bestUntilNow
    } else {
      const mid = start + Math.floor((end - start) / 2)
      if (A[mid] === e) {
        return solve(A, start, mid - 1, e, mid)
      } else if (e < A[mid]) {
        return solve(A, start, mid - 1, e, bestUntilNow)
      } else {
        return solve(A, mid + 1, end, e, bestUntilNow)
      }
    }
  }
  return solve(A, 0, A.length, e, -1)
}

Answer 15

给定一个带有可能重复元素的排序数组，如 [1,1,2,2,2,2,3]，以下时间复杂度为 O(logn) 的代码查找元素第一次和最后一次出现的索引在给定的数组中。此方法基于递归 JS 二进制搜索实现，通过在最初匹配元素后与立即较低或立即较高的索引/元素进行比较（如下所示）。

// Find the first occurence of the value using binary search
function binarySearchFirstOccurence(arr, left, right, value) {
  let middle = Math.floor((left+right)/2);
  if (left > right) {
    return -1;
  } else if (arr[middle] === value && (arr[middle-1] < value || middle === 0)) {
    return middle;
  } else if (arr[middle] < value) {
    return binarySearchFirstOccurence(arr, middle + 1, right, value);
  } else {
    // Going lower
    return binarySearchFirstOccurence(arr, left, middle - 1, value);
  }
}

// Find the last occurence of the value using binary search
function binarySearchLastOccurence(arr, left, right, value) {
  let middle = Math.floor((left+right)/2);
  if (left > right) {
    return -1;
  } else if (arr[middle] === value && (arr[middle+1] > value || middle === arr.length - 1)) {
    return middle;
  } else if (arr[middle] > value) {
    return binarySearchLastOccurence(arr, left, middle - 1, value);
  } else {
    // Going higher
    return binarySearchLastOccurence(arr, middle + 1, right, value);
  }
}

function sortedFrequency(arr, value) {
  let left = 0;
  let right = arr.length -1;
  let first = binarySearchFirstOccurence(arr, left, right, value);
  let last = binarySearchLastOccurence(arr, left, right, value);
  if (first === -1 && last === -1) {
    return -1;
  } else if (first === -1 && last !== -1) {
    return 1;
  } else {
    return last-first+1;
  }
}

let arr = [1,1,2,2,2,2,3];
console.log(sortedFrequency(arr, 3));

最好的 乔治