介绍

二分查找顾名思义就是从序列的中间位置查找，都将目标数字与序列的中间位置数字进行对比，如果目标数字等于中间位置数字则返回对应的序列索引，如果目标数字大于中间位置数字，则继续从有侧的序列中利用二分查找，如果目标数字小于中间位置数字，则继续从左侧的序列中利用二分查找，直到查到目标数字为止。二分法查找的效率很高，但是也有其局限性，比如，目标序列必须是有序的序列，查找的目标如果在序列中有多个，只能查找到一个等。
这里介绍了基础的二分查找算法，并且对其进行了简单的扩展，扩展后增加：

1. 容错功能，当传参不符合要求的时候不会抛出异常
2. 查全功能，可以查到目标序列中全部的目标数字的位置
3. 无序序列处理，如果序列为无序序列时，可以选择是做普通查找还是转换为有序序列后做二分查找
4. 结果格式化，返回结果为一个字典

1、基础的二分查找

说明
baseList 必须为有序的数字序列
targetNum 必须为数字
如果查找到目标数字则返回对应的索引，如果没查找到则返回-1
传参类型错误时会抛出异常

源码

# 二分法查找目标数字，baseList必须为有序的数字序列（列表或元组）
def halfSearchTargetNum(baseList, targetNum):
    leftIndex = 0
    rightIndex = len(baseList) - 1
    while leftIndex <= rightIndex:
        midIndex = int((leftIndex + rightIndex) / 2)
        if baseList[midIndex] < targetNum:
            leftIndex = midIndex + 1
        elif baseList[midIndex] > targetNum:
            rightIndex = midIndex - 1
        else:
            return midIndex
    return -1

调试

if __name__ == '__main__':
    test = [-20, -3, 1, 3, 5, 5, 6, 7.6, 8, 56]
    print('结果1：', halfSearchTargetNum(test, 5))
    print('结果2：', halfSearchTargetNum(test, 7.6))
    print('结果3：', halfSearchTargetNum(test, 56))
    print('结果4：', halfSearchTargetNum(test, -20))
    print('结果5：', halfSearchTargetNum(test, 9))
结果
结果1: 4
结果2: 7
结果3: 9
结果4: 0
结果5: -1    

2、二分查找算法扩展

代码中有详细的注释说明，扩展后增加的内容包括：

1. 容错功能，当传参不符合要求的时候不会抛出异常
2. 查全功能，可以查到目标序列中全部的目标数字的位置
3. 无序序列处理，如果序列为无序序列时，可以选择是做普通查找还是转换为有序序列后做二分查找
4. 结果格式化，返回结果为一个字典

源码

# 扩展二分法查找数字，返回为一个字典
def halfSearchTargetNum(baseList, targetNum, isSorted=False):
    # 参数说明：
    # baseList   目标序列
    # targetNum   目标数字
    # isSorted  默认为False，如果目标序列不是有序序列时，若为False做普通查找，若为True则排序后做二分查找
    targetIndexList = []
    res = {'查找结果': targetIndexList, '目标序列': baseList, '目标数字': targetNum, '说明': ''}

    # 处理baseList类型错误的情况
    if not isinstance(baseList, (list, tuple)):
        res['说明'] = 'baseList不是列表或元组'
        return res

    # 处理baseList元素类型错误的情况
    for item in baseList:
        if not isinstance(item, (int, float)):
            res['说明'] = 'baseList中有非数字元素'
            return res

    # 处理targetNum类型错误的情况
    if not isinstance(targetNum, (int, float)):
        res['说明'] = '目标数字targetNum不是数字类型'
        return res

    # 处理targetNum不在baseList的情况
    if targetNum not in baseList:
        res['说明'] = '目标数字在目标序列中不存在'
        return res

    res['说明'] = '有序序列，二分查找'

    # 处理baseList不是有序序列的情况
    baseListSorted = sorted(baseList)
    if baseList != baseListSorted:
        # isSorted = True时对目标序列重新排序，再对排序后的序列做二分查找
        if isSorted:
            baseList = baseListSorted
            res['原序列'] = res['目标序列']
            res['目标序列'] = baseList
            res['说明'] = '无序序列转有序序列，二分查找'

        # isSorted = False时不重新排序，做普通查找
        else:
            for i in range(0, len(baseList)):
                if baseList[i] == targetNum:
                    targetIndexList.append(i)
            res['说明'] = '无序序列，普通查找'
            return res

    # 开始二分查找
    leftIndex = 0
    rightIndex = len(baseList) - 1
    while leftIndex <= rightIndex:
        midIndex = int((leftIndex + rightIndex) / 2)
        if baseList[midIndex] < targetNum:
            leftIndex = midIndex + 1
        elif baseList[midIndex] > targetNum:
            rightIndex = midIndex - 1
        else:
            # 二分查找到的结果存入列表中
            targetIndexList.append(midIndex)

            # 在二分查找结果右侧继续查找是否还有目标数字，若有就存进列表中，如果遇到不等于目标数字的立即结束查找（因为是有序的，且从左往右查找）
            for i in range(midIndex + 1, rightIndex + 1):
                if baseList[i] != targetNum:
                    break
                else:
                    targetIndexList.append(i)

            # 在二分查找结果左侧继续查找是否还有目标数字，若有就存进列表中，如果遇到不等于目标数字的立即结束查找（因为是有序的，且从右往左查找）
            while leftIndex < midIndex:
                if baseList[midIndex - 1] != targetNum:
                    break
                else:
                    targetIndexList.append(midIndex - 1)
                midIndex -= 1

            # 将结果列表变为有序列表
            targetIndexList.sort()
            return res

调试

if __name__ == '__main__':
    test1 = [5, 5.1, 5.1, 5.1, 5.11]
    test2 = [-20, -3, 92, 12, -2, 12, 7.6, 8, 56]
    test3 = 99
    test4 = [-20, -3, 92, 12, -2, '12', 7.6, 8, 56]
    print('结果1：',halfSearchTargetNum(test1, 5.1))
    print('结果2：',halfSearchTargetNum(test1, 5.1, isSorted=True))
    print('结果3：',halfSearchTargetNum(test2, 12, isSorted=True))
    print('结果4：',halfSearchTargetNum(test2, 12))
    print('结果5：',halfSearchTargetNum(test2, 100))
    print('结果6：',halfSearchTargetNum(test2, '12'))
    print('结果7：',halfSearchTargetNum(test3, 99))
    print('结果8：',halfSearchTargetNum(test4, 12))
结果
结果1： {'查找结果': [1, 2, 3], '目标序列': [5, 5.1, 5.1, 5.1, 5.11], '目标数字': 5.1, '说明': '有序序列，二分查找'}
结果2： {'查找结果': [1, 2, 3], '目标序列': [5, 5.1, 5.1, 5.1, 5.11], '目标数字': 5.1, '说明': '有序序列，二分查找'}
结果3： {'查找结果': [5, 6], '目标序列': [-20, -3, -2, 7.6, 8, 12, 12, 56, 92], '目标数字': 12, '说明': '无序序列转有序序列，二分查找', '原序列': [-20, -3, 92, 12, -2, 12, 7.6, 8, 56]}
结果4： {'查找结果': [3, 5], '目标序列': [-20, -3, 92, 12, -2, 12, 7.6, 8, 56], '目标数字': 12, '说明': '无序序列，普通查找'}
结果5： {'查找结果': [], '目标序列': [-20, -3, 92, 12, -2, 12, 7.6, 8, 56], '目标数字': 100, '说明': '目标数字在目标序列中不存在'}
结果6： {'查找结果': [], '目标序列': [-20, -3, 92, 12, -2, 12, 7.6, 8, 56], '目标数字': '12', '说明': '目标数字不是数字类型'}
结果7： {'查找结果': [], '目标序列': 99, '目标数字': 99, '说明': '目标序列不是列表或元组'}
结果8： {'查找结果': [], '目标序列': [-20, -3, 92, 12, -2, '12', 7.6, 8, 56], '目标数字': 12, '说明': '目标序列中有非数字元素'}