Ruby中奇怪的二进制搜索行为

我试图从头开始在Ruby中实现递归二进制搜索

这是我的代码：

class Searcher

    def get_limits(array)
        [0, array.length - 1]
    end
    
    def binary_search_recursive(array, key)

        low, high = get_limits(array)
    
        mid = (low + high) / 2
    
        return -1 if low > high
    
        return binary_search_recursive(array[low, mid-1], key) if (array[mid] > key)
    
        return binary_search_recursive(array[mid+1, high], key) if (array[mid] < key)
    
        return mid if (array[mid] == key)
    
    end
    
end     

arr = [1,3,4,12,16,21,34,45,55,76,99,101]
key = 34
s = BinarySearch.new
index = s.binary_search_recursive(arr, key)
puts index

类搜索器
def get_限制（阵列）
[0，array.length-1]
结束
def二进制搜索递归（数组、键）
低、高=获取限制（阵列）
中=（低+高）/2
如果低>高，返回-1
返回二进制搜索递归（数组[low，mid-1]，key）if（数组[mid]>key）
返回二进制搜索递归（数组[mid+1，high]，key）if（数组[mid]

当我把“key”设为21时，它奇怪地给出了正确的预期答案，索引5。可以说，当‘key’=3时，我也得到了正确的答案，但我怀疑这是偶然的

你看，只要“钥匙”！=21或3，数组的每个元素都会得到-1、0、1或2。 我到底做错了什么

---

我尝试了几种不同的递归二进制搜索版本，这只是最近的一种。我觉得我每次都会收到相同的问题？

这是我编辑问题后你要问的问题。代码的问题是您正在拆分为新数组，因此34是该数组末尾的唯一元素，因此索引为0

class Searcher
    def binary_search(array, val, low=0, high=(length - 1))
        return nil if high < low
        mid = (low + high) >> 1
        case val <=> array[mid]
          when -1
            binary_search(array, val, low, mid - 1)
          when 1
            binary_search(array, val, mid + 1, high)
          else mid
        end
     end
end     

arr = [1,3,4,12,16,21,34,45,55,76,99,101]
key = 34
s = Searcher.new
index = s.binary_search(arr, key, 0, arr.length)
puts index

类搜索器
def二进制搜索（数组，val，低=0，高=（长度-1））
如果高<低，则返回零
中=（低+高）>>1
case val数组[mid]
当-1
二进制搜索（数组、val、low、mid-1）
当1
二进制搜索（数组、val、中+1、高）
埃尔斯米德
结束
结束
结束
arr=[1,3,4,12,16,21,34,45,55,76,99101]
键=34
s=Searcher.new
索引=s.binary_搜索（arr，key，0，arr.length）
卖出指数

我想在一个充满搜索方法的Searcher类中创建方法。它真的必须在数组类中才能工作吗？我尝试实现您的修复，但使用数组“array”作为参数，但仍然得到相同的错误。如果您将此方法放入数组类中，则可以使用如下方法：

index=array.binary_search（key）

或者您可以通过添加数组作为参数并将

case val self[mid]

更改为

case val array[mid]来进行修改

对于每个递归，您应该缩小数组的范围。您也可以从这里检查内置的二进制搜索方法：谢谢，但我特别尝试从头开始实现它。我从这里找到了一个可行的解决方案：这是一个很棒的实现，但它并不能真正解释OP代码的问题。OP在递归调用中切碎数组，因此它会丢失找到的索引相对于原始数组的位置的上下文。

/2

没有什么问题——它与

>1

相同。您不应该通过切片阵列来创建新阵列，原因有二：1）成本太高；2）子数组在父数组中的位置上下文丢失。@pjs有帮助！这也是为什么我的实现都不起作用的原因；我坚持添加切片以缩短代码。