如何用迭代器实现嵌套迭代并追踪元素在序列中的位置？

你想实现的逻辑本质是：外层逐个遍历数组元素，内层从当前外层元素的位置开始遍历到数组末尾，同步拿到两个位置的元素做处理，类似冒泡排序的遍历节奏。

你最初想到的for x in vec.iter() { for y in x.next() }写法是无法直接工作的：vec.iter()迭代器每次产出的是元素的不可变引用（比如&i32），这类普通值没有实现迭代器接口，本身不存在next方法；同时这种写法也没法记住外层遍历到了哪个位置，没法做到“内层从外层当前位置往后走”的效果。

1. 索引循环（最贴合原生逻辑的写法） #

这种方式和你最初写的类C风格逻辑完全一致，也是Rust里做这类遍历最常用的实现，零额外开销，还能直接拿到元素的位置：

let nums = vec![2, 7, 1, 9, 3];
// 外层遍历到倒数第二个元素即可，如果需要完全匹配你最初写的`i < x.len()-1`的外层循环条件，
// 可以把范围改成 0..nums.len().saturating_sub(1)，避免数组长度过小时越界
for i in 0..nums.len() {
    // 内层从i位置开始一直到末尾
    for j in i..nums.len() {
        // 同时拿到两个位置的元素引用
        let (ele_i, ele_j) = (&nums[i], &nums[j]);
        // 在这里写你的处理逻辑
        println!("位置{}的值{}，位置{}的值{}", i, ele_i, j, ele_j);
    }
}

如果需要修改元素值（比如做排序交换），只要把引用换成可变引用即可：

let mut nums = vec![2, 7, 1, 9, 3];
for i in 0..nums.len() {
    for j in i..nums.len() {
        // *只要i和j是不同的下标，就可以同时拿两个可变引用，不会触发借用错误*
        if i == j { continue; }
        let (ele_i, ele_j) = (&mut nums[i], &mut nums[j]);
        if ele_i > ele_j {
            std::mem::swap(ele_i, ele_j);
        }
    }
}

这种写法里i和j本身就是元素的位置，完全不需要额外记录位置信息，用起来最直接。

2. 纯迭代器风格实现（无手动索引计算） #

如果你不想手动写范围、算索引，可以通过迭代器克隆的方式实现完全一样的逻辑，迭代效果和上面的索引写法完全等价：

let nums = vec![2, 7, 1, 9, 3];
let mut outer_iter = nums.iter();
// 记录外层当前的位置，方便后续获取真实下标
let mut current_i = 0;
while let Some(ele_i) = outer_iter.next() {
    // 克隆当前迭代器，相当于从当前外层位置开始，遍历后续所有元素
    for (offset_j, ele_j) in outer_iter.enumerate() {
        // 计算元素j的真实位置：当前i的位置+迭代的偏移量
        let real_j = current_i + offset_j;
        println!("位置{}的值{}，位置{}的值{}", current_i, ele_i, real_j, ele_j);
    }
    current_i += 1;
}

这种写法的优势是切片迭代器的克隆成本极低，本质只是复制了一个指向切片的指针和长度，没有实际复制数据，性能和索引写法没有差别。

如果需要更简洁的迭代器写法，在引入itertools第三方库的前提下，可以直接通过内置的组合适配器实现：

use itertools::Itertools;
let nums = vec![2, 7, 1, 9, 3];
// combinations_with_replacement 会产出所有i<=j的元素对
for (ele_i, ele_j) in nums.iter().combinations_with_replacement(2) {
    // 处理两个元素即可
}

Rust的标准迭代器提供了内置的enumerate()适配器，只要在迭代时用这个适配器包一层，就可以同步拿到元素的下标和对应的值，完全不需要额外维护位置映射：

• 不可变迭代时：vec.iter().enumerate() 会产出(下标, &元素)的元组
• 可变迭代时：vec.iter_mut().enumerate() 会产出(下标, &mut 元素)的元组

比如上面的迭代器写法里，只要给内层迭代加上enumerate，就能直接拿到j的位置，不需要手动计数。

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