python3 二分法查找算法及功能扩展

介绍

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

  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, '说明': '目标序列中有非数字元素'}

你可能感兴趣的:(python3 二分法查找算法及功能扩展)