二分查找算法的C语言实现以及复杂度分析

二分查找是一种在有序数组中查找特定元素的算法。其基本思想是通过不断地将数组分成两半并排除其中一半来缩小搜索范围。

二分查找算法的C语言实现

#include <stdio.h> 

// 二分查找函数
int binarySearch(int arr[], int l, int r, int x) 
{
    while (l <= r) // 当左边界不超过右边界时循环,begin和end是左闭右闭区间，因此有=号
    {  
        assert(arr);
        int mid = l + (r - l) / 2;  // 计算中间位置，防止溢出

        // 检查中间位置的元素是否是目标值
        if (arr[mid] == x) 
            return mid;  // 找到目标，返回索引

        // 如果目标值小于中间元素，则只需在左半部分查找
        if (arr[mid] > x) 
            r = mid - 1;  // 调整右边界
        else
            l = mid + 1;  // 否则，调整左边界
    }

    return -1;  // 目标值不在数组中
}

int main(void) {
    int arr[] = {2, 3, 4, 10, 40};  
    int n = sizeof(arr) / sizeof(arr[0]);  // 计算数组长度
    int x = 10;  // 设定要查找的值
    int result = binarySearch(arr, 0, n - 1, x);  // 调用二分查找函数

    // 输出结果
    if (result == -1)
        printf("元素不在数组中");
    else
        printf("元素在索引 %d 处", result);

    return 0;  
}

二分查找算法的时间复杂度主要取决于数组被分割的次数。在每一步中，搜索范围减少到原来的一半。因此，最坏情况下，算法的时间复杂度为 O(log n)，其中 n 是数组的长度。

可以想象每次查找都把一张纸折了一半，纸折半了多少次就除了多少个2。除了多少个2就相当于找了多少次。假设折半查找了x次，2^x = N。x = log N (log以2为底，N的对数)。

最好的情况就是只分割了一次就刚好找到，所以是 O(1)
最坏的情况是找不到或者只剩一个 -- O(log2 N)

在迭代版本的二分查找中，空间复杂度为 O(1)。

以下是python的实现。

def binary_search(arr, l, r, x):
    if r >= l:
        mid = l + (r - l) // 2

        # 如果元素在中间
        if arr[mid] == x:
            return mid

        # 如果元素小于中间的元素，那么它只可能在左子数组中
        elif arr[mid] > x:
            return binary_search(arr, l, mid - 1, x)

        # 否则元素只可能在右子数组中
        else:
            return binary_search(arr, mid + 1, r, x)

    # 元素不在数组中
    else:
        return -1

arr = [2, 3, 4, 10, 40]
x = 10

# 函数调用
result = binary_search(arr, 0, len(arr) - 1, x)

if result != -1:
    print(f"元素在索引 {result} 处")
else:
    print("元素不在数组中")

Python的实现与C语言版本非常相似，定义一个函数 binary_search，它接收一个列表、搜索范围的左右边界 l 和 r，以及要查找的元素 x 。然后使用递归来不断缩小搜索范围。