如何通过迭代器获取向量元素对的可变引用？Rust冒泡排序问题

你遇到的问题根源在于windows(2)返回的是不可变的切片引用迭代器，每个元素类型是&[T]，而swap操作需要可变引用，所以编译器报错。

为什么标准库没有直接的相邻可变元素迭代器？ #

Rust的借用规则禁止同时持有重叠的可变引用，相邻元素对（比如(v[0],v[1])和(v[1],v[2])）会共享v[1]的可变引用，这违反了可变引用的唯一性原则，因此标准库没有提供这类迭代器。

解决方案1：用索引实现规范的冒泡排序 #

这是最直接且安全的方式，通过索引逐个获取相邻元素的可变引用：

fn bubble_sort<T: Ord>(v: &mut [T]) {
    let len = v.len();
    for i in 0..len {
        let mut swapped = false;
        // 每次遍历后，最后i个元素已经有序，无需再比较
        for j in 0..len - i - 1 {
            if v[j] > v[j + 1] {
                v.swap(j, j + 1);
                swapped = true;
            }
        }
        // 没有交换说明已经有序，提前退出
        if !swapped {
            break;
        }
    }
}

解决方案2：自定义安全的相邻可变元素迭代器 #

如果一定要用迭代器风格，可以自己实现一个符合借用规则的迭代器，利用split_at_mut拆分切片来避免重叠可变引用：

// 自定义相邻可变元素迭代器
struct AdjacentMutIter<'a, T> {
    slice: &'a mut [T],
    current: usize,
}

impl<'a, T> AdjacentMutIter<'a, T> {
    fn new(slice: &'a mut [T]) -> Self {
        AdjacentMutIter { slice, current: 0 }
    }
}

impl<'a, T> Iterator for AdjacentMutIter<'a, T> {
    type Item = (&'a mut T, &'a mut T);

    fn next(&mut self) -> Option<Self::Item> {
        // 剩余元素不足两个时停止迭代
        if self.current + 1 >= self.slice.len() {
            return None;
        }

        // 拆分切片为前current+1个元素和剩余部分，保证两个引用不重叠
        let (left, right) = self.slice.split_at_mut(self.current + 1);
        let first = &mut left[self.current];
        let second = &mut right[0];

        self.current += 1;
        Some((first, second))
    }
}

// 使用自定义迭代器实现冒泡排序
fn bubble_sort_with_iter<T: Ord>(v: &mut [T]) {
    let len = v.len();
    for i in 0..len {
        let mut swapped = false;
        let mut iter = AdjacentMutIter::new(&mut v[0..len - i]);
        while let Some((a, b)) = iter.next() {
            if *a > *b {
                std::mem::swap(a, b);
                swapped = true;
            }
        }
        if !swapped {
            break;
        }
    }
}

这个自定义迭代器完全符合Rust的安全规则，没有使用unsafe代码，因为split_at_mut会确保返回的两个切片不重叠，从而保证获取的可变引用唯一且安全。

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