以符合Rust惯用风格的方式比较向量连续元素查找局部极值

Great question! When working with sequential elements in Rust, the slice::windows method is your go-to tool for this kind of sliding window problem—it’s far more idiomatic than manually tracking previous elements or juggling indexes. Let’s break down how to use it cleanly:

1. 核心方案：使用slice::windows生成滑动窗口 #

The windows method on slices creates an iterator over overlapping windows of the specified size. Perfect for our case, since we need to check every triplet of consecutive elements.

Here’s a straightforward implementation:

fn main() {
    let v = vec![1.0, 3.0, 2.0, 5.0, 4.0, 0.0, 1.0];
    
    // 遍历长度为3的重叠滑动窗口
    for window in v.windows(3) {
        // 用模式匹配解构窗口中的三个元素
        let [prev, current, next] = window else {
            // 理论上不会进入这个分支，因为windows(3)只会返回长度为3的切片
            continue;
        };
        
        if prev < current && current > next {
            println!("找到局部极大值：{}", current);
        } else if prev > current && current < next {
            println!("找到局部极小值：{}", current);
        }
    }
}

为什么这比你之前的实现更优： #

• 无需手动管理索引：不用再担心偏移错误或者计算1..v.len()-2这类范围，迭代器会自动处理所有边界逻辑
• 仅借用不消费：和into_iter会夺走Vec所有权不同，windows只是借用切片，处理完后你还能继续使用原Vec
• 代码意图清晰：任何人看到v.windows(3)都能立刻明白你在处理连续的三元组元素

2. 封装成可复用的迭代器函数 #

为了提升灵活性，你可以把逻辑封装成返回迭代器的函数，这符合Rust优先使用迭代器进行惰性、可组合操作的惯用风格：

#[derive(Debug, Clone, Copy)]
enum Extremum {
    LocalMax(f64),
    LocalMin(f64),
}

fn find_local_extrema(v: &[f64]) -> impl Iterator<Item = Extremum> + '_ {
    v.windows(3)
        .filter_map(|window| {
            let [prev, current, next] = window else {
                return None;
            };
            
            match (prev < current, current > next) {
                (true, true) => Some(Extremum::LocalMax(*current)),
                _ if prev > current && current < next => Some(Extremum::LocalMin(*current)),
                _ => None,
            }
        })
}

fn main() {
    let v = vec![1.0, 3.0, 2.0, 5.0, 4.0, 0.0, 1.0];
    
    // 遍历找到的极值
    for extremum in find_local_extrema(&v) {
        match extremum {
            Extremum::LocalMax(val) => println!("局部极大值：{}", val),
            Extremum::LocalMin(val) => println!("局部极小值：{}", val),
        }
    }
    
    // 原Vec依然可以正常使用！
    println!("原向量内容：{:?}", v);
}

这种实现的优势： #

• 零成本抽象：迭代器是惰性求值的，除非你主动消费它（比如收集到Vec中），否则不会额外分配内存
• 可组合性：你可以链式调用其他迭代器方法（比如take、skip、collect），按照需求灵活处理结果
• 类型安全：用枚举区分极大值和极小值，避免了结果歧义

3. 处理边界情况 #

如果你的Vec长度小于3，windows(3)会返回空迭代器——这符合逻辑，因为没有前后元素的话，无法判断局部极值。如果你的业务场景需要把首尾元素视为极值（比如只和一个邻居比较），可以单独添加针对首尾的判断，但这已经偏离了标准的局部极值定义。

和你手动跟踪元素方案的对比 #

你之前手动维护two_before和one_before的方法是可行的，但更容易出错且可读性较差。windows方案消除了手动维护状态变量的需求，让代码的意图一目了然。

内容的提问来源于stack exchange，提问作者exocortex