搜索——二分法查找_二分法查找元素位置-优快云博客

先初始化指针𝑖 = 0和𝑗 = 𝑛−1，分别指向数组首元素和尾元素，代表搜索区间[0, 𝑛 −1]。
接下来，循环执行以下两步：
1. 计算中点索引𝑚=(𝑖+𝑗)//2，其中//表示向下取整操作。
2. 判断nums[m] 和target 的大小关系，分为以下三种情况。
1. 当nums[m] < target 时，说明target 在区间[𝑚+1,𝑗]中，因此执行𝑖 = 𝑚+1。
2. 当nums[m] > target 时，说明target 在区间[𝑖,𝑚−1]中，因此执行𝑗 = 𝑚−1。
3. 当nums[m] = target 时，说明找到target ，因此返回索引𝑚。
若数组不包含目标元素，搜索区间最终会缩小为空。此时返回−1。

三、代码实现（Python）

def binary_search(nums, target):
    i, j = 0, len(nums) - 1
    while i <= j:
        m = (i + j) // 2
        if nums[m] == target:
            return m
        elif nums[m] < target:
            i = m + 1
        else:
            j = m - 1
    return -1

a = [5, 7, 8, 12, 15, 1, 19, 17, 6]
a.sort()
print(binary_search(a, 8))

四、优点和局限性

二分查找在时间和空间方面都有较好的性能。
‧ 二分查找的时间效率高。在大数据量下，对数阶的时间复杂度具有显著优势。例如，当数据大小𝑛= $2^{20}$ 时，线性查找需要 $2^{20}$ =1048576轮循环，而二分查找仅需 $\log {_{2}}^{}$ $2^{20}$ =20轮循环。
‧ 二分查找无须额外空间。相较于需要借助额外空间的搜索算法（例如哈希查找），二分查找更加节省空间。

然而，二分查找并非适用于所有情况，主要有以下原因。
‧ 二分查找仅适用于有序数据。若输入数据无序，为了使用二分查找而专门进行排序，得不偿失。因为排序算法的时间复杂度通常为𝑂(𝑛log𝑛)，比线性查找和二分查找都更高。对于频繁插入元素的场景，为保持数组有序性，需要将元素插入到特定位置，时间复杂度为𝑂(𝑛)，也是非常昂贵的。
‧ 二分查找仅适用于数组。二分查找需要跳跃式（非连续地）访问元素，而在链表中执行跳跃式访问的效率较低，因此不适合应用在链表或基于链表实现的数据结构。
‧ 小数据量下，线性查找性能更佳。在线性查找中，每轮只需要1次判断操作；而在二分查找中，需要1次加法、1次除法、1~3次判断操作、1次加法（减法），共4~6个单元操作；因此，当数据量𝑛较小时，线性查找反而比二分查找更快。

五、二分查找插入点

1. 无重复元素的情况

给定一个长度为𝑛的有序数组nums 和一个元素 target 。如果数组不存在重复元素，则将target插入到数组nums中，并保持其有序性。若数组中已存在元素 target，则插入到其左方。请返回插入后 target 在数组中的索引。

1）思考

问题一：当数组中包含target 时，插入点的索引是否是该元素的索引？
要求将target 插入到相等元素的左边，这意味着新插入的target替换了原来target 的位置。也就是说，当数组包含 target 时，插入点的索引就是该target的索引。

问题二：当数组中不存在target 时，插入点是哪个元素的索引？

进一步思考二分查找过程：当 nums[m] < target 时 𝑖 移动，这意味着指针𝑖在向大于等于近。同理，指针𝑗始终在向小于等于 target 的元素靠近。

因此二分结束时一定有：𝑖指向首个大于 target 的元素，𝑗指向首个小于target 的元素。易得当数组不包含target 时，插入索引为𝑖。

2）代码

def binary_search_insertion_simple(nums, target):
    i, j = 0, len(nums) - 1
    while i <= j:
        m = (i + j) // 2
        if nums[m] == target:
            return m
        elif nums[m] < target:
            i = m + 1
        else:
            j = m - 1
    return i

a = [5, 7, 8, 12, 15, 1, 19, 17, 6]
a.sort()
print(binary_search_insertion_simple(a, 10))  # 插入不存在的数字10，返回索引5

2. 有重复元素的情况

1）思考

假设数组中存在多个target ，则普通二分查找只能返回其中一个target 的索引，而无法确定该元素的左边和右边还有多少 target。题目要求将目标元素插入到最左边，所以我们需要查找数组中最左一个target 的索引。

2）整体流程

每轮先计算中点索引𝑚，再判断target 和nums[m] 大小关系，分为以下几种情况：

‧ 当 nums[m] < target 或 nums[m] > target 时，说明还没有找到 target 和 target ，因此采用普通二分查找的缩小区间操作，从而使指针𝑖和𝑗向target 靠近。

‧ 当 nums[m] == target 时，说明小于target的元素在区间[𝑖,𝑚−1]中，因此采用𝑗 = 𝑚−1来缩小区间，从而使指针𝑗向小于target 的元素靠近。

循环完成后，𝑖指向最左边的target ，𝑗 指向首个小于target 的元素，因此索引𝑖就是插入点。

3）代码

def binary_search_insertion(nums, target):
     i, j = 0, len(nums)- 1 # 初始化双闭区间 [0, n-1]
     while i <= j:
         m = (i + j) // 2 # 计算中点索引 m
         if nums[m] < target:
            i = m + 1 # target 在区间 [m+1, j] 中
         elif nums[m] > target:
            j = m- 1 # target 在区间 [i, m-1] 中
         else:
            j = m- 1 # 首个小于 target 的元素在区间 [i, m-1] 中
     if i >= 0 and nums[i] == target:  # 验证target是否在数组中
         return i
     else:
         return -1

a = [5, 7, 8, 12, 15, 1, 19, 17, 6, 6, 6]
a.sort()
print(binary_search_insertion(a, 6))   #返回最左边的目标数据6的索引为2

六、二分查找边界

给定一个长度为𝑛的有序数组nums ，数组可能包含重复元素。请返回数组中最左一个元素target 的索引。若数组中不包含该元素，则返回−1。

1. 查找左边界

回忆二分查找插入点的方法，搜索完成后𝑖指向最左一个 target 的索引。因此查找插入点本质上是在查找最左一个 target的索引。

2. 查找右边界

当 nums[m] <= target 时，向右移动 i，最终 j 将指向最右侧的 target

def binary_search_insertion_r(nums, target):
     i, j = 0, len(nums)- 1 # 初始化双闭区间 [0, n-1]
     while i <= j:
         m = (i + j) // 2 # 计算中点索引 m
         if nums[m] < target:
            i = m + 1 # target 在区间 [m+1, j] 中
         elif nums[m] > target:
            j = m- 1 # target 在区间 [i, m-1] 中
         else:
            i = m + 1 # 首个大于 target 的元素在区间 [m+1, j] 中
     if j >= 0 and nums[j] == target:    # 验证target是否在数组中
         return j
     else:
         return -1
a = [5, 7, 8, 12, 15, 1, 19, 17, 15, 15, 15]
a.sort()
print(binary_search_insertion_r(a, 15))