二分查找算法

二分查找

算法概述

二分查找是在有序数据集中查找目标值的一种高效算法。它的基本思想是：把目标值与查找范围内的中间值比较，如果相等返回该值的在整个序列中的位置。如果不相等，则根据大小关系缩小一半的查找范围，继续查找，直到找到目标值或者查找范围为空。

算法适用条件

1. 数据集有序，并且静态不变，即不会频繁插入、删除元素。
2. 依赖的数据结构是数组，需要支持随机访问元素。
3. 不适合数据量太小的情况，数据量太小时，顺序查找更快。
4. 不适合数据量太大的情况，数据量太大时，需要大量连续内存空间，因为是算法基于数组的。

算法实现

// 基础：序列有序没有重复元素
func BinarySearch(arr []int, target int) int {
    left, right := 0, len(arr)-1

    for left <= right {
        mid := left + (right-left)/2
        if arr[mid] == target{
            return mid 
        } else if arr[mid] < target{
            left = mid + 1
        } else {
            right = mid - 1
        }
    }
    // 没有找到目标值
    return -1
}

// 扩展1: 有序序列中有重复元素，查找第一个等于目标值的元素
func BinarySearchFirst(arr []int, target int) int {
    left, right := 0, len(arr)-1

    for left <= right {
        mid := left + (right-left)/2
        if arr[mid] < target {
            left = mid + 1
        } else if arr[mid] > target {
            right = mid - 1
        } else {
            // 如果 mid 为 0 或者 mid 前一个元素不等于 target，说明 mid 就是第一个等于 target 的元素
            if mid == 0 || arr[mid-1] != target {
                return mid
            } else {
                right = mid - 1
            }
        }
    }
    return -1
}

// 扩展2: 有序序列中有重复元素，查找最后一个等于目标值的元素
func BinarySearchLast(arr []int, target int) int {
    left, right := 0, len(arr)-1

    for left <= right {
        mid := left + (right-left)/2
        if arr[mid] < target {
            left = mid + 1
        } else if arr[mid] > target {
            right = mid - 1
        } else {
            // 如果 mid 为 n-1 或者 mid 后一个元素不等于 target，说明 mid 就是最后一个等于 target 的元素
            if mid == len(arr)-1 || arr[mid+1] != target {
                return mid
            } else {
                left = mid + 1
            }
        }
    }
    return -1
}

// 扩展3: 有序序列中有重复元素，查找第一个大于等于目标值的元素
func BinarySearchFirstGreaterOrEqual(arr []int, target int) int {
    left, right := 0, len(arr)-1

    for left <= right {
        mid := left + (right-left)/2
        if arr[mid] < target {
            left = mid + 1
        } else {
            // 如果 mid 为 0 或者 mid 前一个元素小于 target，说明 mid 就是第一个大于等于 target 的元素
            if mid == 0 || arr[mid-1] < target {
                return mid
            } else {
                right = mid - 1
            }
        }
    }
    return -1
}

// 扩展4: 有序序列中有重复元素，查找最后一个小于等于目标值的元素
func BinarySearchLastLessOrEqual(arr []int, target int) int {
    left, right := 0, len(arr)-1

    for left <= right {
        mid := left + (right-left)/2
        if arr[mid] > target {
            right = mid - 1
        } else {
            // 如果 mid 为 n-1 或者 mid 后一个元素大于 target，说明 mid 就是最后一个小于等于 target 的元素
            if mid == len(arr)-1 || arr[mid+1] > target {
                return mid
            } else {
                left = mid + 1
            }
        }
    }
    return -1
}