分治算法③-使用分治算法实现二分查找-python

二分搜索

        该问题的常见形式是在一个有序数组中寻找某个元素。在本例子中假设数组array[ ]已经升序排列，变量left表示查找范围的左边界，right表示查找范围的有边界，mid表示查找范围的中间位置，target为要查找的元素。

        用分治法实现过程如下：    

        ①初始化。令left=0,即指向array[ ]的第一个元素；right=array.length-1,即指向有序列表array[ ]的最后一个元素。    

        ②mid=（left+right）// 2，即指向查找范围的中间元素。(low+high)为奇数的话，除以2并不能得到整数，此处向下取整，比如：4.5向下取整为4。    

        ③判定 left<=right是否成立，如果成立，转第4步，否则，说明该列表中没有指定元素，算法结束。    

        ④判断target 与 array[mid] 的关系。如果 target==array[mid] ，搜索成功，算法结束；如果 target >array[mid] ，令 left=middle+1，继续在数组的后半部分进行搜索;如果 target

 二分搜索有递归实现和非递归实现两种方式，非递归实现代码如下：

def binarySearch1(arr, len, target):
    # 初始化左右搜索边界
    left = 0
    right = len - 1
    while left <= right:
        # 中间位置：两边界元素之和/2向下取整
        mid = (left + right) // 2
        # arr[mid]大于target，即要寻找的元素在左半边，所以需要设定右边界为mid - 1，搜索左半边
        if target < arr[mid]:
            right = mid - 1
        # arr[mid]小于target，即要寻找的元素在右半边，所以需要设定左边界为mid+1，搜索右半边
        elif target > arr[mid]:
            left = mid + 1
            # 搜索到对应元素
        elif target == arr[mid]:
            return mid
        # 搜索不到返回 - 1
    return -1
​
​
alist = [9, 12, 23, 12, 12, 15, 33, 12, 32, 131]
length = len(alist)
target = 131
alist.sort()
result = binarySearch1(alist, length, target)
print(result)

 二分搜索递归实现代码如下：

def binarySearch2(array, left, right, target):
    if (left <= right):
        mid = (left + right) // 2
        # 搜索到对应元素
        if array[mid] == target:
            return mid
        elif array[mid] < target:
            # array[mid]小于target，即要寻找的元素在右半边，所以需要设定左边界为mid + 1，搜索右半边
            return binarySearch2(array, mid + 1, right, target)
        else:
            # array[mid]大于target，即要寻找的元素在左半边，所以需要设定右边界为mid - 1，搜索左半边
            return binarySearch2(array, left, mid - 1, target)
    else:
        return -1
​
​
alist = [9, 12, 23, 12, 12, 15, 33, 12, 32, 131]
length = len(alist)
target = 12
alist.sort()
result = binarySearch2(alist, 0, length - 1, target)
print(result)

二分搜索递归及非递归完整代码如下：

# 非递归方式实现二分搜索
def binarySearch1(arr, len, target):
    # pr初始化左右搜索边界
    left = 0
    right = len - 1
    while left <= right:
        # pr中间位置：两边界元素之和/ 2向下取整
        mid = (left + right) // 2
        # 搜索左半边 pr
        if target < arr[mid]:
            right = mid - 1
        # 搜索右半边
        elif target > arr[mid]:
            left = mid + 1
        # 搜索到对应元素
        elif target == arr[mid]:
            return mid
    return -1
​
​
# 递归方式实现二分搜索
def binarySearch2(array, left, right, target):
    if left <= right:
        mid = (left + right) // 2
        # 搜索到对应元素
        if array[mid] == target:
            return mid
        elif array[mid] < target:
            # array[mid]小于target，即要寻找的元素在右半边，所以需要设定左边界为mid + 1，搜索右半边
            return binarySearch2(array, mid + 1, right, target)
        else:
            # array[mid]大于target，即要寻找的元素在左半边，所以需要设定右边界为mid - 1，搜索左半边
            return binarySearch2(array, left, mid - 1, target)
    else:
        return -1
​
​
if __name__ == '__main__':
    array = [2, 13, 25, 69, 88]
    array.sort()
    location = binarySearch1(array, len(array), 13)
    print("非递归实现，查找到的元素位置为:" + str(location))
    location = binarySearch2(array, 0, len(array) - 1, 69)
    print("递归实现，查找到的元素位置为:" + str(location))