Rust 练习册 32：二分查找与算法实现艺术

星释2025-11-21 10:23

在计算机科学中，搜索算法是最基础也是最重要的算法之一。二分查找（Binary Search）作为一种高效的搜索算法，在有序数组中查找特定元素时具有 O(log n) 的时间复杂度，远优于线性查找的 O(n)。在 Exercism 的 "binary-search" 练习中，我们将实现这个经典的算法，这不仅能帮助我们掌握算法设计的基本思想，还能深入学习 Rust 中的数组处理和错误处理技巧。

什么是二分查找？

二分查找是一种在有序数组中查找特定元素的搜索算法。它的工作原理如下：

  1. 首先比较数组中间元素与目标值
  2. 如果中间元素等于目标值，则查找成功
  3. 如果目标值小于中间元素，则在数组左半部分继续查找
  4. 如果目标值大于中间元素，则在数组右半部分继续查找
  5. 重复以上步骤，直到找到目标值或搜索范围为空

让我们先看看练习提供的函数签名：

rust 复制代码 
pub fn find(array: &[i32], key: i32) -> Option<usize> {
    unimplemented!(
        "Using the binary search algorithm, find the element '{}' in the array '{:?}' and return its index.",
        key,
        array
    );
}

我们需要实现这个函数，它应该：

  1. 在有序数组中查找指定元素
  2. 如果找到，返回元素的索引
  3. 如果未找到，返回 None

算法实现

1. 基础实现

rust 复制代码 
pub fn find(array: &[i32], key: i32) -> Option<usize> {
    let mut left = 0;
    let mut right = array.len();
    
    while left < right {
        let mid = left + (right - left) / 2;
        
        match array[mid].cmp(&key) {
            std::cmp::Ordering::Equal => return Some(mid),
            std::cmp::Ordering::Greater => right = mid,
            std::cmp::Ordering::Less => left = mid + 1,
        }
    }
    
    None
}

这个实现的关键点：

  • 使用左闭右开区间 [left, right)
  • 通过 cmp 方法进行三路比较
  • 避免整数溢出：使用 left + (right - left) / 2 而不是 (left + right) / 2

2. 递归实现

rust 复制代码 
pub fn find(array: &[i32], key: i32) -> Option<usize> {
    binary_search_recursive(array, key, 0, array.len())
}

fn binary_search_recursive(array: &[i32], key: i32, left: usize, right: usize) -> Option<usize> {
    if left >= right {
        return None;
    }
    
    let mid = left + (right - left) / 2;
    
    match array[mid].cmp(&key) {
        std::cmp::Ordering::Equal => Some(mid),
        std::cmp::Ordering::Greater => binary_search_recursive(array, key, left, mid),
        std::cmp::Ordering::Less => binary_search_recursive(array, key, mid + 1, right),
    }
}

递归版本更直观地体现了分治思想。

测试用例分析

通过查看测试用例，我们可以更好地理解需求：

rust 复制代码 
#[test]
fn finds_a_value_in_an_array_with_one_element() {
    assert_eq!(find(&[6], 6), Some(0));
}

最简单的成功情况。

rust 复制代码 
#[test]
fn finds_a_value_in_the_middle_of_an_array() {
    assert_eq!(find(&[1, 3, 4, 6, 8, 9, 11], 6), Some(3));
}

在中间位置找到元素。

rust 复制代码 
#[test]
fn identifies_that_a_value_is_not_included_in_the_array() {
    assert_eq!(find(&[1, 3, 4, 6, 8, 9, 11], 7), None);
}

查找不存在的元素。

rust 复制代码 
#[test]
fn nothing_is_included_in_an_empty_array() {
    assert_eq!(find(&[], 1), None);
}

空数组的边界情况。

rust 复制代码 
#[test]
#[ignore]
#[cfg(feature = "generic")]
fn works_for_str_elements() {
    assert_eq!(find(["a"], "a"), Some(0));
    assert_eq!(find(["a", "b"], "b"), Some(1));
}

泛型支持的测试用例。

泛型实现

为了支持不同类型的元素，我们可以实现泛型版本：

rust 复制代码 
pub fn find<T: Ord>(array: &[T], key: T) -> Option<usize> {
    let mut left = 0;
    let mut right = array.len();
    
    while left < right {
        let mid = left + (right - left) / 2;
        
        match array[mid].cmp(&key) {
            std::cmp::Ordering::Equal => return Some(mid),
            std::cmp::Ordering::Greater => right = mid,
            std::cmp::Ordering::Less => left = mid + 1,
        }
    }
    
    None
}

通过添加 T: Ord 约束，我们的函数可以用于任何实现了 Ord trait 的类型。

使用标准库实现

Rust 标准库已经提供了二分查找功能，我们可以直接使用：

rust 复制代码 
pub fn find(array: &[i32], key: i32) -> Option<usize> {
    array.binary_search(&key).ok()
}

对于泛型版本：

rust 复制代码 
use std::cmp::Ord;

pub fn find<T: Ord>(array: &[T], key: T) -> Option<usize> {
    array.binary_search(&key).ok()
}

性能优化版本

考虑边界条件的优化实现：

rust 复制代码 
pub fn find(array: &[i32], key: i32) -> Option<usize> {
    // 空数组的快速处理
    if array.is_empty() {
        return None;
    }
    
    let mut left = 0;
    let mut right = array.len() - 1;
    
    // 提前检查边界值
    if array[left] > key || array[right] < key {
        return None;
    }
    
    // 使用闭区间 [left, right]
    while left <= right {
        let mid = left + (right - left) / 2;
        
        match array[mid].cmp(&key) {
            std::cmp::Ordering::Equal => return Some(mid),
            std::cmp::Ordering::Greater => {
                if mid == 0 {
                    return None; // 防止下溢
                }
                right = mid - 1;
            },
            std::cmp::Ordering::Less => left = mid + 1,
        }
    }
    
    None
}

错误处理和边界情况

在实际应用中，我们需要考虑更多边界情况：

rust 复制代码 
pub fn find(array: &[i32], key: i32) -> Option<usize> {
    // 处理空数组
    if array.is_empty() {
        return None;
    }
    
    let mut left = 0;
    let mut right = array.len();
    
    // 使用标准的左闭右开区间实现
    while left < right {
        // 使用安全的中点计算防止溢出
        let mid = left + (right - left) / 2;
        
        match array[mid].cmp(&key) {
            std::cmp::Ordering::Equal => return Some(mid),
            std::cmp::Ordering::Greater => right = mid,
            std::cmp::Ordering::Less => left = mid + 1,
        }
    }
    
    None
}

扩展功能

基于基础实现，我们可以添加更多功能：

rust 复制代码 
pub struct BinarySearch;

impl BinarySearch {
    /// 标准二分查找
    pub fn find<T: Ord>(array: &[T], key: &T) -> Option<usize> {
        let mut left = 0;
        let mut right = array.len();
        
        while left < right {
            let mid = left + (right - left) / 2;
            
            match array[mid].cmp(key) {
                std::cmp::Ordering::Equal => return Some(mid),
                std::cmp::Ordering::Greater => right = mid,
                std::cmp::Ordering::Less => left = mid + 1,
            }
        }
        
        None
    }
    
    /// 查找第一个大于等于 key 的元素位置
    pub fn lower_bound<T: Ord>(array: &[T], key: &T) -> usize {
        let mut left = 0;
        let mut right = array.len();
        
        while left < right {
            let mid = left + (right - left) / 2;
            
            if array[mid] < *key {
                left = mid + 1;
            } else {
                right = mid;
            }
        }
        
        left
    }
    
    /// 查找第一个大于 key 的元素位置
    pub fn upper_bound<T: Ord>(array: &[T], key: &T) -> usize {
        let mut left = 0;
        let mut right = array.len();
        
        while left < right {
            let mid = left + (right - left) / 2;
            
            if array[mid] <= *key {
                left = mid + 1;
            } else {
                right = mid;
            }
        }
        
        left
    }
    
    /// 查找元素的所有出现位置
    pub fn find_all<T: Ord>(array: &[T], key: &T) -> Vec<usize> {
        let lower = Self::lower_bound(array, key);
        let upper = Self::upper_bound(array, key);
        
        (lower..upper).collect()
    }
}

算法复杂度分析

二分查找的复杂度分析：

  1. 时间复杂度：O(log n)

    • 每次迭代都将搜索空间减半
    • 最多需要 log₂(n) 次比较

  2. 空间复杂度：

    • 迭代版本：O(1)
    • 递归版本：O(log n)（递归调用栈）

实际应用场景

二分查找在实际开发中有广泛的应用：

  1. 数据库索引：B+树等数据结构的基础
  2. 版本控制：Git 中查找特定提交
  3. 游戏开发：在有序列表中查找资源
  4. 搜索引擎：在倒排索引中查找文档
  5. 数值计算：求解单调函数的根

与其他搜索算法的比较

rust 复制代码 
// 线性查找 - O(n)
pub fn linear_search<T: PartialEq>(array: &[T], key: &T) -> Option<usize> {
    for (i, item) in array.iter().enumerate() {
        if item == key {
            return Some(i);
        }
    }
    None
}

// 二分查找 - O(log n)
pub fn binary_search<T: Ord>(array: &[T], key: &T) -> Option<usize> {
    let mut left = 0;
    let mut right = array.len();
    
    while left < right {
        let mid = left + (right - left) / 2;
        
        match array[mid].cmp(key) {
            std::cmp::Ordering::Equal => return Some(mid),
            std::cmp::Ordering::Greater => right = mid,
            std::cmp::Ordering::Less => left = mid + 1,
        }
    }
    
    None
}

对于大型有序数据集，二分查找的优势非常明显。

总结

通过 binary-search 练习，我们学到了：

  1. 算法设计：掌握了二分查找的核心思想和实现技巧
  2. 边界处理：学会了如何正确处理各种边界情况
  3. 泛型编程：理解了如何编写通用的算法实现
  4. 性能优化：了解了防止整数溢出等优化技巧
  5. 标准库使用：熟悉了 Rust 标准库提供的相关功能
  6. 扩展功能：学会了实现 lower_bound、upper_bound 等变种算法

这些技能在实际开发中非常有用，特别是在处理有序数据、实现高效搜索和进行算法优化时。二分查找作为一个经典算法，涉及到了算法设计的许多核心概念，是学习 Rust 算法实现的良好起点。

通过这个练习，我们也看到了 Rust 在算法实现方面的强大能力，以及如何用安全且高效的方式表达算法逻辑。这种结合了安全性和性能的语言特性正是 Rust 的魅力所在。

相关推荐
zl_vslam2 小时前
SLAM中的非线性优-3D图优化之四元数在Opencv-PNP中的应用（五）
人工智能·算法·计算机视觉
机器学习之心2 小时前
经典粒子群优化算法PSO-LSTM回归+SHAP分析+多输出+新数据预测！Matlab代码实现
算法·lstm·pso-lstm·shap分析
William_cl2 小时前
C# ASP.NET Controller 核心：ViewResult 实战指南（return View (model) 全解析）
开发语言·c#·asp.net
wtrees_松阳2 小时前
Flask数据加密实战：医疗系统安全指南
开发语言·python
皮影w2 小时前
Java SpringAOP入门
java·开发语言
Jtti2 小时前
IPv4与IPv6共存下的访问问题排查方法
开发语言·php
周杰伦fans2 小时前
CommunityToolkit.Mvvm（又称MVVM Toolkit） 与 MvvmLight 的核心区别
开发语言·c#·.netcore
小青龙emmm2 小时前
2025级C语言第四次周测题解
c语言·开发语言·算法
树在风中摇曳3 小时前
【牛客排序题详解】归并排序 & 快速排序深度解析（含 C 语言完整实现）
c语言·开发语言·算法
热门推荐
01GitHub 镜像站点02今天 Cloudflare 全球事故，连 GPT 和你的网站都一起“掉线”了03UV安装并设置国内源04Google Antigravity：无法登录？早期错误、登录修复和用户反馈指南05BongoCat - 跨平台键盘猫动画工具06安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）07Linux下V2Ray安装配置指南08【保姆级教程】免费使用Gemini3的5种方法！免翻墙/国内直连09全球最强模型Grok4，国内已可免费使用！（附教程）10Labelme从安装到标注：零基础完整指南