Scala 二进制搜索不起作用

下面是一个二进制搜索算法，但它没有找到值：

我不认为这个算法是正确的

“theArray”被初始化为一个0的数组，位置7处的项等于4

object various {

  //O(log N)

  def binarySerachForValue(value : Int) = {

    var arraySize = 100
    var theArray = new Array[Int](arraySize)
    theArray(7) = 4
    var timesThrough = 0
    var lowIndex = 0
    var highIndex = arraySize - 1

    while(lowIndex <= highIndex){
        var middleIndex = (highIndex + lowIndex) / 2

        if(theArray(middleIndex) < value)
            lowIndex = middleIndex + 1
        else if(theArray(middleIndex) > value)
            highIndex = middleIndex - 1

        else {
            println("Found match in index " + middleIndex)
            lowIndex = highIndex + 1
        }

        timesThrough = timesThrough + 1

    }

    timesThrough
  }                                               //> binarySerachForValue: (value: Int)Int
    binarySerachForValue(4)                       //> res0: Int = 7
}

对象不同{
//O（对数N）
def二进制SerachForValue（值：Int）={
var arraySize=100
var theArray=新数组[Int]（数组大小）
数组（7）=4
var timesThrough=0
var lowIndex=0
var highIndex=阵列化-1
while（低索引值）
highIndex=middleIndex-1
否则{
println（“在索引中找到匹配项”+middleIndex）
低指数=高指数+1
}
timesThrough=timesThrough+1
}
穿越
}//>二进制SerachForValue:（值：Int）Int
二进制SerachForValue（4）/>res0:Int=7
}

循环应该是这样的：

while(lowIndex <= highIndex){
    //note the lowIndex + other
    var middleIndex = lowIndex + ((highIndex + lowIndex) / 2)

    if(theArray(middleIndex) < value)
        lowIndex = middleIndex + 1
    else if(theArray(middleIndex) > value)
        highIndex = middleIndex - 1

    else return middleIndex 

    timesThrough = timesThrough + 1

}
// if loop finished and not returned middleIndex in last else, return -1 (not found)
return -1

while（低索引值）
highIndex=middleIndex-1
否则返回中间索引
timesThrough=timesThrough+1
}
//如果循环已完成，并且在最后一个else中未返回middleIndex，则返回-1（未找到）
返回-1

它看起来像是二进制搜索算法的正确实现，但您提供了一个0的数组，索引7处只有一个数字。二进制搜索通常采用一个排序值数组（尽管可以首先实现排序）

下面是一个示例，说明了为什么首先需要排序数组：

搜索（4）

数组=[0,4,0,0,0]

第一次迭代，看数组（2），它等于0。0<4，因此使用上半部分（即下半部分指数=中间指数+1

newArray=[0,0]

然后我们再次迭代并最终退出循环，因为我们从未找到它。使用排序列表，您的技术将运行良好

---

如果要在0的数组中查找单个值，最好的方法是在数组中迭代，直到找到为止。祝您好运。

假设数组已正确排序，您可以使用尾部优化递归编写功能更强大的搜索函数，如下所示：

def binarySearchForValue(value : Int, theArray:Array[Int]) = {        
  @tailrec
  def doSearch(arr:Array[Int], index:Int = 0):Int = {        
    val middleIndex = arr.size / 2
    val splits = arr.splitAt(middleIndex)
    val totalIndex = middleIndex + index
    arr(middleIndex) match{
      case i if i == value => totalIndex
      case i if i < value => doSearch(splits._2, totalIndex)
      case _ => doSearch(splits._1 dropRight(1), totalIndex)
    }
  }
  doSearch(theArray)
} 

def binarySearchForValue(value : Int, theArray:Array[Int]) = {        
  @tailrec
  def doSearch(low:Int, high:Int):Int = {
    val mid = (low + high) / 2
    if(mid >= theArray.size) -1 
    else {
        val currval = theArray(mid)
        if (currval == value) mid
        else if (currval < value) doSearch(mid+1, high)
        else doSearch(low, mid - 1)
    }
  }
  doSearch(0, theArray.size)
}

def binarySearchForValue（值：Int，数组：Array[Int]）={
@泰勒克
def doSearch（arr:Array[Int]，index:Int=0）：Int={
val middleIndex=平均尺寸/2
val splits=arr.splitAt（中间索引）
val totalIndex=中间索引+索引
arr（中间索引）匹配{
如果i==value=>totalIndex，则为案例一
如果idoSearch（拆分2，totalIndex），则为案例一
案例u=>doSearch（拆分为1个dropRight（1），totalIndex）
}
}
doSearch（theArray）
} 

请注意，这也可以通过稍微不同的方式实现，如下所示：

def binarySearchForValue(value : Int, theArray:Array[Int]) = {        
  @tailrec
  def doSearch(arr:Array[Int], index:Int = 0):Int = {        
    val middleIndex = arr.size / 2
    val splits = arr.splitAt(middleIndex)
    val totalIndex = middleIndex + index
    arr(middleIndex) match{
      case i if i == value => totalIndex
      case i if i < value => doSearch(splits._2, totalIndex)
      case _ => doSearch(splits._1 dropRight(1), totalIndex)
    }
  }
  doSearch(theArray)
} 

def binarySearchForValue(value : Int, theArray:Array[Int]) = {        
  @tailrec
  def doSearch(low:Int, high:Int):Int = {
    val mid = (low + high) / 2
    if(mid >= theArray.size) -1 
    else {
        val currval = theArray(mid)
        if (currval == value) mid
        else if (currval < value) doSearch(mid+1, high)
        else doSearch(low, mid - 1)
    }
  }
  doSearch(0, theArray.size)
}

def binarySearchForValue（值：Int，数组：Array[Int]）={
@泰勒克
def doSearch（低：整数，高：整数）：整数={
val mid=（低+高）/2
如果（中间>=阵列大小）-1
否则{
val currval=阵列（中间）
如果（currval==值）中间
否则如果（电流<值）数据搜索（中+1，高）
else-doSearch（低、中-1）
}
}
doSearch（0，数组大小）
}

二进制搜索只有在数组/集合项已经排序的情况下才有效。在您的情况下，您的数组中有100个元素，所有元素都用零填充，只有第7个索引为4。此外，您的代码有一种非常必要的感觉。如果您使用Scala编写，建议您将其编写为“功能性”的尽可能面向对象。请看一个想法。您的代码原因似乎不符合以下实现所示：BinarySarchForValue（7，数组（2,3,5,6,7,8））//>res0:Int=1@user470184，这是因为我们在连续的迭代中丢失了精确的数组索引位置，因为我们将数组减半。更好的方法是只使用上下限进行搜索。该算法。@cmbaxter，我继续对您的帖子进行了编辑。如果我的编辑很好，应该很快就会出现。@cmbaxter，你能为子孙后代添加一个示例binsearch算法吗？其他答案都没有显示从Scala的角度功能定位的递归binsearch算法。@S.R.I，我修复了我的解决方案，也发布了你的解决方案。