Algorithm 我的算法应该搜索二进制，但我不知道为什么它不起作用

我的二进制搜索算法不起作用。你能帮我吗

它应该从给定的排序数组值中找到目标值。 如果找不到该值，则返回None

def binarySearch(values: Array[Int], target: Int): Option[Int] = {
    val n = values.size
    var left = 0
    var right = n - 1
    while(left <= right){
      val mid = (left + right) / 2
      val value = values(mid)
      if(value == target)
        return Some(mid)
      else if(value < target)
        right = mid
      else
        left = mid
    }
    None
  }

def binarySearch（值：数组[Int]，目标：Int）：选项[Int]={
val n=值。大小
左变量=0
var right=n-1
而（左这是工作代码

def binarySearch(arr: Array[Int], left: Int, right: Int, target: Int) {


    if (right >= left)
        var mid = int((left + right) / 2)

        if (arr[mid] == target)
            return mid

        else if (arr[mid] < target)
            return binarySearch(arr, mid+1, right, target)

        else if (arr[mid] > target):
            return binarySearch(arr, left, mid-1, target)
    else:
        return -1
}

def二进制搜索（arr:Array[Int]，左：Int，右：Int，目标：Int）{
如果（右>=左）
var mid=int（（左+右）/2）
中频（arr[mid]==目标）
中途返回
其他if（arr[mid]<目标）
返回二进制搜索（arr，mid+1，右，目标）
否则如果（arr[mid]>目标）：
返回二进制搜索（arr、左、中1、目标）
其他：
返回-1
}
您的代码存在许多问题

首先是
while
循环条件，
左-右

有一个简单的解决方法：
while（left
。但不幸的是，这会创建两个退出结果，无法找到目标或目标是最终值，因此我们需要在退出
while
循环后进行测试

if (values(left) == target) Some(left) else None

下一个问题是，您为当前
mid
值调整了错误的变量。简单的解决方法是将
if（value
更改为
if（value>target）

另外，在您知道
mid
不是我们要寻找的目标后，它不必保留在将来的任何分组中。因此，该部分如下所示：

else if(value > target)
  right = mid-1
else
  left = mid+1

最后，您的代码不会处理空数组条件。让我们在末尾添加该测试

if (n > 0 && values(left) == target) Some(left) else None

所以现在代码通过了我对它的所有测试。不幸的是，它仍然是一个由可变变量和命令式编程组成的丑陋的大杂烩。不是我们喜欢的干净的FP Scala风格

这里有一个可能的替代方案值得考虑

def binarySearch(values :Array[Int], target :Int) :Option[Int] = {
  def bs(lo :Int, hi :Int) :Option[Int] = {
    val mid = (lo + hi)/2
    target compare values(mid) match {
      case  0             => Some(mid)    //found
      case _ if mid == lo => None         //can't be found
      case -1             => bs(lo, mid)  //lower half
      case  1             => bs(mid, hi)  //upper half
    }
  }
  values.headOption.flatMap(_ => bs(0, values.length))
}

测试：

val arr = Array(1,2,3,5,6)
binarySearch(arr,0)               //res0: Option[Int] = None
binarySearch(arr,1)               //res1: Option[Int] = Some(0)
binarySearch(arr,2)               //res2: Option[Int] = Some(1)
binarySearch(arr,3)               //res3: Option[Int] = Some(2)
binarySearch(arr,4)               //res4: Option[Int] = None
binarySearch(arr,5)               //res5: Option[Int] = Some(3)
binarySearch(arr,6)               //res6: Option[Int] = Some(4)
binarySearch(arr,7)               //res7: Option[Int] = None
binarySearch(Array.empty[Int],8)  //res8: Option[Int] = None

你怎么说它不起作用？你的测试条件、预期结果、实际结果是什么？“不起作用”不是一个足够精确的错误描述，我们无法帮助您。什么不起作用？它如何起作用？您的代码有什么问题？您是否收到错误消息？错误消息是什么？您得到的结果是否不是您期望的结果？您期望的结果是什么？为什么，您得到的结果是什么，以及如何处理两种不同？您观察到的行为不是期望的行为吗？期望的行为是什么，为什么，观察到的行为是什么，它们有什么不同？作为参考，2.13 scala库在中提供了二进制搜索