Python 二进制搜索实现

我一直在执行5种不同的二进制chop任务。你能给我一些关于更多方法的想法吗？这就是我得到的： 一,

二,

3我知道，这和第一次很相似

class find(object):
    def __init__(self, key, array):
        self.array = array
        self.key = key
        self.l = 0
        self.r = len(array)

    def left_chop(self):
        while self.l<self.r:
            self.step()
        return self.l if self.key == self.array[self.l] else -1

    def step(self):
        m = (self.l+self.r)/2
        if self.key<=self.array[m]:
            self.r = m
        else:
            self.l = m+1

---

我曾试图用函数式编程的风格来设计一些东西，但没有成功。

4这一个使用递归。如果中间值正确，则返回索引。否则，它会将数组一分为二并以这种方式继续搜索

def getIndexOf(search, array):
    arrlen = len(array)
    halfindex = arrlen / 2 - ((arrlen % 2) / 2)
    value = array[halfindex]
    if len(array) < 2 and array[0] != search:
        return -1;
    if value == search:
        return halfindex
    elif search < value:
        return getIndexOf(search, array[0:halfindex])
    else:
        return getIndexOf(search, array[halfindex:arrlen] + halfindex)

---

您可以使用发电机：

def chopper(array, val):
    edges = (0, len(array))
    while True:
        m = sum(edges)/2
        edges = (edges[0], m) if array[m] >= val else (m+1, edges[1])
        yield edges

def chopSearch(array, val):
    for l, r in chopper(array, val):
        if array[l] == val:
            return l
        if l==r:
            return -1

---

随机分割搜索

当前节点=根。 在找不到时重复。 如果当前节点=所需值，则找到。 如果所需整数小于根，则从0到indexroot随机选取一个索引。设置当前节点=拾取的索引。 否则，从根到n-1随机选取一个索引。设置当前节点=拾取的索引。

---

1.二进制搜索算法的简单实现

def binary_search(seq, t):
min = 0
max = len(seq) - 1
  while True:
     if max < min:
       return -1
       m = (min + max) // 2
     if seq[m] < t:
       min = m + 1
     elseif seq[m] > t:
       max = m - 1
   else:
      return m

二进制搜索的替代方法

def binarySearch(alist, item):
    first = 0
    last = len(alist)-1
    found = False
while first<=last and not found:
     midpoint = (first + last)//2
if alist[midpoint] == item:
   found = True
 else
if item < alist[midpoint]:
last = midpoint-1
 else:
first = midpoint+1
    return found
testlist = [0, 1, 2, 8, 13, 17, 19, 32, 42,]
print(binarySearch(testlist, 3))
print(binarySearch(testlist, 13))

3.python编程中处理二进制搜索的第三种不同方法

   def binarySearch(alist, item):
        if len(alist) == 0:
            return False
        else:
            midpoint = len(alist)//2
            if alist[midpoint]==item:
              return True
            else:
              if item<alist[midpoint]:
                return binarySearch(alist[:midpoint],item)
              else:
                return binarySearch(alist[midpoint+1:],item)
        testlist = [0, 1, 2, 8, 13, 17, 19, 32, 42,]
       print(binarySearch(testlist, 3))
       print(binarySearch(testlist, 13))

---

函数式编程意味着多个函数，每个函数都有各自的单一用途，对于给定的输入返回相同的输出：

def chopSearch(array, value):
    while len(array) != 1:
        if value == getMiddle(array):
            return value
        else:
            array = getNewArray(array, lessThan(array, value))
    return if array[0] == value value else -1

def getMiddle(array):
    return if (len(array) % 2 == 0) array[len(array)/2] else array[(len(array)+1)/2]

def lessThan(array, value):
    return if getMiddle(array) > value true else false

def getNewArray(array, isLess):
    return if isLess array[0:getMiddle(array)] else array[getMiddle(array)+1:len(array)-1]

作为一个caviat，我不懂python，所以我花了一分钟的时间来尝试编写这篇文章。请随意修复您看到的任何pyton错误

由PSF提供

In [1]: import bisect

In [2]: bisect??
def bisect_left(a, x, lo=0, hi=None):
    """Return the index where to insert item x in list a, assuming a is sorted.

    The return value i is such that all e in a[:i] have e < x, and all e in
    a[i:] have e >= x.  So if x already appears in the list, a.insert(x) will
    insert just before the leftmost x already there.

    Optional args lo (default 0) and hi (default len(a)) bound the
    slice of a to be searched.
    """

    if lo < 0:
        raise ValueError('lo must be non-negative')
    if hi is None:
        hi = len(a)
    while lo < hi:
        mid = (lo+hi)//2
        if a[mid] < x: lo = mid+1
        else: hi = mid
    return lo

---

Python不是最适合函数式编程的语言，如果你喜欢函数式编程，你会喜欢scala，在纯Python的对分模块中也有对分算法，我将尝试scala。有这样的模块，但它使用的方法与第一个类似：第一个不是有效的Python。谢谢，我编辑了这篇文章。你可能会发现站点Rosetta代码很有用。它以多种语言和样式显示算法的实现。这是页面和部分。我对其进行了编辑，以便在数组中不存在搜索时不会超过最大递归深度。添加if search not in array会挫败二进制搜索背后的整个思想，不是吗？在第一个递归中，它将对数组进行完整的运行。。。如果lenarray<2并搜索！=数组[0]：返回-1。还有，在你的最后一行有太多…在最坏的情况下，它在O n中工作，这不是一个完全的二进制搜索，但谢谢！这是一种有趣的方法。我们仍然在切割，所以它仍然是二进制的。唯一的变化是，我们从当前节点的所有代中随机选取一个子节点，而不是在二进制搜索中转到下一个子节点。所以最坏的情况仍然是logn。对于大数据集，随机化已被证明是一种有效的优化技术，因此该方法是；顺便说一句，使用切片+1：这比OP的第一个片段好多少？我觉得这比你三个选择中的任何一个都要干净

def chopSearch(array, value):
    while len(array) != 1:
        if value == getMiddle(array):
            return value
        else:
            array = getNewArray(array, lessThan(array, value))
    return if array[0] == value value else -1

def getMiddle(array):
    return if (len(array) % 2 == 0) array[len(array)/2] else array[(len(array)+1)/2]

def lessThan(array, value):
    return if getMiddle(array) > value true else false

def getNewArray(array, isLess):
    return if isLess array[0:getMiddle(array)] else array[getMiddle(array)+1:len(array)-1]

In [1]: import bisect

In [2]: bisect??
def bisect_left(a, x, lo=0, hi=None):
    """Return the index where to insert item x in list a, assuming a is sorted.

    The return value i is such that all e in a[:i] have e < x, and all e in
    a[i:] have e >= x.  So if x already appears in the list, a.insert(x) will
    insert just before the leftmost x already there.

    Optional args lo (default 0) and hi (default len(a)) bound the
    slice of a to be searched.
    """

    if lo < 0:
        raise ValueError('lo must be non-negative')
    if hi is None:
        hi = len(a)
    while lo < hi:
        mid = (lo+hi)//2
        if a[mid] < x: lo = mid+1
        else: hi = mid
    return lo