Duplicates 如果数组包含重复项，则进行二进制搜索

嗨

如果我们使用二进制搜索在以下数组中搜索24，那么搜索键的索引是什么

array = [10,20,21,24,24,24,24,24,30,40,45]

---

< P>我怀疑二进制搜索，如果数组有重复的值，它是如何工作的。任何人可以澄清…

< p>你所提出的数组在中间索引中有目标值，而在最有效的实现中，在第一个递归级别之前返回这个值。此实现将返回“5”（中间索引）

要理解该算法，只需在调试器中逐步完成代码

public class BinarySearch {
    public static int binarySearch(int[] array, int value, int left, int right) {
          if (left > right)
                return -1;
          int middle = left + (right-left) / 2;
          if (array[middle] == value)
                return middle;
          else if (array[middle] > value)
                return binarySearch(array, value, left, middle - 1);
          else
                return binarySearch(array, value, middle + 1, right);           
    }

    public static void main(String[] args) {
        int[] data = new int[] {10,20,21,24,24,24,24,24,30,40,45};

        System.out.println(binarySearch(data, 24, 0, data.length - 1));
    }
}

公共a类{
公共静态int二进制搜索（int[]数组，int值，int左，int右）{
如果（左>右）
返回-1；
中间整数=（左+右）/2；
if（数组[中间]==值）
{
if（数组[middle-1]值）
返回二进制搜索（数组、值、左、中-1）；
其他的
返回二进制搜索（数组，值，中间+1，右）；
}
公共静态int二进制搜索1（int[]数组，int值，int左，int右）{
如果（左>右）
返回-1；
中间整数=（左+右）/2；
if（数组[中间]==值）
{
if（数组[中间]值）
返回binarySearch1（数组、值、左、中-1）；
其他的
返回binarySearch1（数组，值，中间+1，右）；
}
公共静态void main（字符串[]args）{
int[]数据=新的int[]{10,20,21,24,24,24,24,24,30,40,45}；
System.out.println（binarySearch（data，24，0，data.length-1））；//第一个索引
System.out.println（binarySearch1（data，24，0，data.length-1））；//最后一个索引
}
}

正如@Pleepleus所指出的，它将从递归的第一级本身返回索引5。不过，我想指出关于二进制搜索的几点：

使用

mid=left+（right-left）/2来代替
mid=left+（right-left）/2

如果要搜索元素的

下限

或

上限

，请使用以下算法：

binLowerBound(a, lo, hi, x)
  if (lo > hi)
    return lo;

  mid = lo +  (hi - lo) / 2;
  if (a[mid] == x)
    return binLowerBound(a, lo, mid-1, x);
  else if (a[mid] > x)
    return binLowerBound(a, lo, mid-1, x);
  else
    return binLowerBound(a, mid+1, hi, x);

binHigherBound(a, lo, hi, x)
  if (lo > hi)
    return lo;
  mid = lo + (hi - lo) / 2;
  if (a[mid] == x)
    return binHigherBound(a, mid+1, hi, x);
  else if (a[mid] > x)
    return binHigherBound(a, lo, mid-1, x);
  else
    return binHigherBound(a, mid+1, hi, x);

---

为了完整起见，这里有一个typescript示例，非递归版本（二进制运算符用于强制对整数执行操作，而不是浮点算术）示例可以轻松转换为其他类似C的语言：

function binarySearch(array: number[], query: number): [number, number] {
    let from: number;
    let till: number;

    let mid = 0 | 0;
    let min = 0 | 0;
    let max = array.length - 1 | 0;

    while (min < max) {
        mid = (min + max) >>> 1;

        if (array[mid] < query) {
            min = mid + 1 | 0;
        } else {
            max = mid - 1 | 0;
        }
    }

    mid = min;
    min--;
    max++;

    from = array[mid] < query ? (array[max] === query ? max : mid) : (array[mid] === query ? mid : min);

    min = 0 | 0;
    max = array.length - 1 | 0;

    while (min < max) {
        mid = (min + max) >>> 1;

        if (query < array[mid]) {
            max = mid - 1 | 0;
        } else {
            min = mid + 1 | 0;
        }
    }

    mid = min;
    min--;
    max++;

    till = array[mid] > query ? (array[min] === query ? min : mid) : (array[mid] === query ? mid : max);

    return [from, till];
}

函数二进制搜索（数组：number[]，查询：number）：[number，number]{
出租人：数量；
让我们来看看：数字；
设mid=0 | 0；
设min=0 | 0；
设max=array.length-1 | 0；
同时（最小值<最大值）{
中间=（最小+最大）>>>1；
if（数组[mid]>>1；
if（查询<数组[mid]）{
max=mid-1 | 0；
}否则{
最小值=中间值+1 | 0；
}
}
中=分钟；
闵--；
max++；
直到=数组[mid]>查询？（数组[min]==查询？最小值：mid）：（数组[mid]==查询？mid:最大值）；
返回[从，直到]；
}

以下是如何使用它：

let array = [1, 3, 3, 3, 5, 5, 5, 5, 5, 5, 7];

console.log(binarySearch(array, 0)); // Gives [ -1,  0 ] <= No value found, note that resulting range covers area beyond array boundaries
console.log(binarySearch(array, 1)); // Gives [  0,  0 ] <= Singular range (only one value found)
console.log(binarySearch(array, 2)); // Gives [  0,  1 ] <= Queried value not found, however the range covers argument value
console.log(binarySearch(array, 3)); // Gives [  1,  3 ] <= Multiple values found
console.log(binarySearch(array, 4)); // Gives [  3,  4 ] <= Queried value not found, however the range covers argument value
console.log(binarySearch(array, 5)); // Gives [  4,  9 ] <= Multiple values found
console.log(binarySearch(array, 6)); // Gives [  9, 10 ] <= Queried value not found, however the range covers argument value
console.log(binarySearch(array, 7)); // Gives [ 10, 10 ] <= Singular range (only one value found)
console.log(binarySearch(array, 8)); // Gives [ 10, 11 ] <= No value found, note that resulting range covers area beyond array boundaries

let数组=[1,3,3,5,5,5,5,7]；
log（binarySearch（array，0））；//给出[-1，0]它可以在唯一和非唯一数组中工作

def binary_search(n,s):
  search = s
  if len(n) < 1:
    return "{} is not in array".format(search)
  if len(n) == 1 and n[0] != s:
    return "{} is not in array".format(search)
  
  mid = len(n)//2
  ele = n[mid]
  if search == ele:
    return "{} is in array".format(search)
  elif search > ele:
    return binary_search(n[mid:],search)
  else:
    return binary_search(n[:mid],search)

def二进制搜索（n，s）：
搜索=s
如果len（n）<1：
返回“{}不在数组中”。格式（搜索）
如果len（n）==1且n[0]！=s：
返回“{}不在数组中”。格式（搜索）
mid=len（n）//2
ele=n[mid]
如果搜索==ele：
返回“{}在数组中”。格式（搜索）
elif搜索>元素：
返回二进制搜索（n[mid:]，搜索）
其他：
返回二进制搜索（n[：mid]，搜索）
您是在问‘如果我要实现二进制搜索，并且得到这个数组并要求我查找24的索引，我应该返回什么？’还是在问‘如果我通过其他人的二进制搜索实现运行这个数组，我太懒了，返回值会是什么？’如果可能，您可以告诉这两种情况。。这将是非常感谢的…显然结果将是数组[5]。太棒了！不过只测试了下限！
def binary_search(n,s):
  search = s
  if len(n) < 1:
    return "{} is not in array".format(search)
  if len(n) == 1 and n[0] != s:
    return "{} is not in array".format(search)
  
  mid = len(n)//2
  ele = n[mid]
  if search == ele:
    return "{} is in array".format(search)
  elif search > ele:
    return binary_search(n[mid:],search)
  else:
    return binary_search(n[:mid],search)