python中的二进制搜索算法

我试图用python实现二进制搜索，并编写了如下代码。但是，我不能让它在指针_元素大于数组中最大的元素时停止

你能帮忙吗？谢谢

def binary_search(array, needle_element):
    mid = (len(array)) / 2
    if not len(array):
        raise "Error"
    if needle_element == array[mid]:
        return mid
    elif needle_element > array[mid]:
        return mid + binary_search(array[mid:],needle_element)
    elif needle_element < array[mid]:
        return binary_search(array[:mid],needle_element)
    else:
        raise "Error"

def二进制搜索（数组、指针元素）：
mid=（len（数组））/2
如果不是len（数组）：
提出“错误”
如果针_元素==数组[mid]：
中途返回
elif针\u元素>阵列[mid]：
返回mid+二进制搜索（数组[mid:]，指针元素）
elif针_元素<数组[mid]：
返回二进制搜索（数组[：mid]，指针元素）
其他：
提出“错误”

如果进行二进制搜索，我猜数组已排序。如果这是真的，您应该能够将数组中的最后一个元素与

针\u元素进行比较。正如八达通所说，这可以在搜索开始之前完成。
在开始搜索之前，您只需检查
指针\u元素是否在数组的边界内即可。这将使它更有效，因为你不必做几个步骤就可以完成

if needle_element < array[0] or needle_element > array[-1]:
    # do something, raise error perhaps?

如果针形元素<数组[0]或针形元素>数组[-1]：
#做点什么，也许会引起错误？
在
针\u元素>数组[mid]
的情况下，您当前将
数组[mid::
传递给递归调用。但是您知道
array[mid]
太小了，所以您可以通过
array[mid+1://code>来代替（并相应地调整返回的索引）

如果指针比数组中的所有元素都大，这样做最终会得到一个空数组，并且会按预期引发错误

注意：对于大型阵列，每次创建子阵列都会导致性能不佳。最好是传入数组的边界。
array[mid:]每次调用它时都会创建一个新的子副本=slow。还可以使用递归，这在Python中也很慢

试试这个：

def binarysearch(sequence, value):
    lo, hi = 0, len(sequence) - 1
    while lo <= hi:
        mid = (lo + hi) // 2
        if sequence[mid] < value:
            lo = mid + 1
        elif value < sequence[mid]:
            hi = mid - 1
        else:
            return mid
    return None

def二进制搜索（序列、值）：
lo，hi=0，len（序列）-1
而lo则最好使用
较低的
和
较高的
索引，正如Lasse V.Karlsen在对该问题的评论中所建议的那样

这就是代码：

def二进制搜索（数组，目标）：
下限=0
上限=透镜（阵列）
下<上：#使用<代替val:
如果lower==x:#这两条是实际的线
休息，你在找什么
下=x
elif目标


lower
一旦到达较小的数字（从左侧）就会停止

if lower==x:break
将在达到较高的数字（从右侧）后停止

例如：

>>> binary_search([1,5,8,10], 5)   # return 1
1
>>> binary_search([1,5,8,10], 0)   # return None
>>> binary_search([1,5,8,10], 15)  # return None

为什么不使用对分模块？它应该可以完成您所需要的工作——您需要维护和测试的代码更少。
您可以按照其他人的建议改进您的算法，但让我们先看看它不起作用的原因：

你陷入了一个循环中，因为如果
needle\u element>array[mid]
，你将在下一步搜索的对分数组中包含element
mid
。因此，如果指针不在数组中，您最终将永远搜索长度为1的数组。而是传递
array[mid+1::
（即使
mid+1
不是有效的索引，这也是合法的），最终将使用长度为零的数组调用函数。因此
len（array）==0
表示“未找到”，而不是错误。适当地处理它。
以上所有答案都是正确的，但我认为分享我的代码会有所帮助

def binary_search(number):
    numbers_list = range(20, 100)
    i = 0
    j = len(numbers_list)
    while i < j:
        middle = int((i + j) / 2)
        if number > numbers_list[middle]:
            i = middle + 1
        else:
            j = middle
    return 'the index is '+str(i)

def二进制搜索（数字）：
数字列表=范围（20，100）
i=0
j=len（数字列表）
而i编号列表[中间]：
i=中间+1
其他：
j=中间
返回“索引为”+str（i）
使用递归返回数组中键的索引。

round（）是一个函数，用于将浮点值转换为整数，使代码快速，并转到预期的情况[O（logn）]

A=[1,2,3,4,5,6,7,8,9,10]
低=0
hi=len（A）
v=3
def BS（A、低、高、v）：
中间=圆形（（高+低）/2.0）
如果v==mid：
打印（“你找到了杜德！”+“+”v的索引是，A.Index（v））
elif v
如果没有上/下索引，也应该这样做：

def exists_element(element, array):
    if not array:
        yield False

    mid = len(array) // 2
    if element == array[mid]:
        yield True
    elif element < array[mid]:
        yield from exists_element(element, array[:mid])
    else:
        yield from exists_element(element, array[mid + 1:])

def存在\u元素（元素，数组）：
如果不是数组：
假屈服
mid=len（数组）//2
如果元素==数组[mid]：
屈服于真实
elif元素<数组[mid]：
从现有元素（元素，数组[：mid]）的产量
其他：
从元素（元素，数组[mid+1:]）中的收益率
这是一个尾部递归解决方案，我认为这比复制部分数组然后跟踪索引以返回更干净：

def binarySearch(elem, arr):
    # return the index at which elem lies, or return false
    # if elem is not found
    # pre: array must be sorted
    return binarySearchHelper(elem, arr, 0, len(arr) - 1)

def binarySearchHelper(elem, arr, start, end):
    if start > end:
        return False
    mid = (start + end)//2
    if arr[mid] == elem:
        return mid
    elif arr[mid] > elem:
        # recurse to the left of mid
        return binarySearchHelper(elem, arr, start, mid - 1)
    else:
        # recurse to the right of mid
        return binarySearchHelper(elem, arr, mid + 1, end)

使用递归：

def binarySearch(arr,item):
    c = len(arr)//2
    if item > arr[c]:
       ans = binarySearch(arr[c+1:],item)
       if ans:
          return binarySearch(arr[c+1],item)+c+1
    elif item < arr[c]:
       return binarySearch(arr[:c],item)
    else:
       return c

binarySearch([1,5,8,10,20,50,60],10)

def二进制搜索（arr，项）：
c=len（arr）//2
如果项目>arr[c]：
ans=binarySearch（arr[c+1:]，item）
如果答案是：
返回二进制搜索（arr[c+1]，item）+c+1
elif项目

如果值在列表中，则返回布尔值

捕获列表的第一个和最后一个索引，循环并分割捕获中间值的列表。
在每个循环中都将执行相同的操作，然后比较输入值是否等于中间值

def二进制搜索（数组，值）：
数组=已排序（数组）
第一个=0
last=len（数组）-1
而第一个中值：
第一个=midIndex+1
返回错误
我会尽量避免创建大量数组的部分副本，而是传入上下索引。然后你就简单地说
def binarySearch(elem, arr):
    # return the index at which elem lies, or return false
    # if elem is not found
    # pre: array must be sorted
    return binarySearchHelper(elem, arr, 0, len(arr) - 1)

def binarySearchHelper(elem, arr, start, end):
    if start > end:
        return False
    mid = (start + end)//2
    if arr[mid] == elem:
        return mid
    elif arr[mid] > elem:
        # recurse to the left of mid
        return binarySearchHelper(elem, arr, start, mid - 1)
    else:
        # recurse to the right of mid
        return binarySearchHelper(elem, arr, mid + 1, end)

def binarySearch(arr,item):
    c = len(arr)//2
    if item > arr[c]:
       ans = binarySearch(arr[c+1:],item)
       if ans:
          return binarySearch(arr[c+1],item)+c+1
    elif item < arr[c]:
       return binarySearch(arr[:c],item)
    else:
       return c

binarySearch([1,5,8,10,20,50,60],10)

def binarySearch(array, value):
  array = sorted(array)
  first = 0
  last = len(array) - 1

  while first <= last:
    midIndex = (first + last) // 2
    midValue = array[midIndex]

    if value == midValue:
      return True
    if value < midValue:
      last = midIndex - 1
    if value > midValue:
      first = midIndex + 1
  return False