pyhon的bisect模块（二分查找与插入）

bisect.bisect_left(a, x, lo=0, hi=len(a))

• 找到a中第一个不小于x(大于等于x)的元素的下标

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

bisect.bisect_right(a, x, lo=0, hi=len(a))

• 找到a中第一个大于x的元素的下标

def bisect_right(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 after the rightmost 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 x < a[mid]: hi = mid
        else: lo = mid+1
    return lo

bisect.bisect(a, x, lo=0, hi=len(a))

• 等价于bisect.bisect_right(a, x, lo=0, hi=len(a))

bisect.insort_left(a, x, lo=0, hi=len(a))

• 找到a中第一个不小于x(大于等于x)的元素的下标，然后将x插入到这个位置

def insort_left(a, x, lo=0, hi=None):
    """Insert item x in list a, and keep it sorted assuming a is sorted.

    If x is already in a, insert it to the left of the leftmost x.

    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
    a.insert(lo, x)

bisect.insort_right(a, x, lo=0, hi=len(a))

• 找到a中第一个大于x的元素的下标，然后将x插入到这个位置

def insort_right(a, x, lo=0, hi=None):
   """Insert item x in list a, and keep it sorted assuming a is sorted.

   If x is already in a, insert it to the right of the rightmost x.

   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 x < a[mid]: hi = mid
       else: lo = mid+1
   a.insert(lo, x)

bisect.insort(a, x, lo=0, hi=len(a))

• 等价于bisect.insort_right(a, x, lo=0, hi=len(a))

举例如下

import bisect

alist = [5, 5, 9, 9, 14, 14, 16, 16, 19, 19]
print(bisect.bisect_left(alist, 9)) #2
print(bisect.bisect_right(alist, 9)) #4 
print(bisect.bisect(alist, 9)) #4
print(bisect.bisect_left(alist,20)) #10
print(bisect.bisect_right(alist,20)) #10
print(bisect.bisect_left(alist, 5)) #0
print(bisect.bisect_right(alist, 5))#2


#对于插入来说，插入的位置可能会不同，但最终得到的结果都是一样的
alist = [5, 5, 9, 9, 14, 14, 16, 16, 19, 19]
bisect.insort_left(alist,5)
print(alist) #[5, 5, 5, 9, 9, 14, 14, 16, 16, 19, 19]

alist = [5, 5, 9, 9, 14, 14, 16, 16, 19, 19]
bisect.insort_right(alist,5)
print(alist) #[5, 5, 5, 9, 9, 14, 14, 16, 16, 19, 19]

参考

• bisect — 数组二分查找算法