Rust 双端迭代器：从两端出发的优雅遍历

2301_81651611

718人浏览 · 2025-10-30 23:00:36

2301_81651611 · 2025-10-30 23:00:36 发布

Rust 双端迭代器：从两端出发的优雅遍历

引言

在 Rust 的迭代器生态中，DoubleEndedIterator 是一个容易被忽视但功能强大的 trait。它不仅支持从前向后遍历，还能从后向前遍历，这种双向能力在特定场景下能极大简化算法实现。本文将深入探讨双端迭代器的设计哲学、实现机制和实战应用，帮助你掌握这一高级特性。🎯

核心概念与设计哲学

Trait 定义

pub trait DoubleEndedIterator: Iterator {
    fn next_back(&mut self) -> Option<Self::Item>;
}

设计洞察：DoubleEndedIterator 继承自 Iterator，意味着它必须同时支持 next() 和 next_back()。这种设计体现了 Rust 的组合性原则——在基础能力上叠加高级特性。

语义约束

双端迭代器必须满足一个重要不变式：从前向后和从后向前的遍历最终会在中间相遇，且不会遗漏或重复元素。

fn invariant_demonstration() {
    let data = vec![1, 2, 3, 4, 5];
    let mut iter = data.iter();
    
    assert_eq!(iter.next(), Some(&1));        // 从前取
    assert_eq!(iter.next_back(), Some(&5));   // 从后取
    assert_eq!(iter.next(), Some(&2));        // 从前取
    assert_eq!(iter.next_back(), Some(&4));   // 从后取
    assert_eq!(iter.next(), Some(&3));        // 最后一个元素
    assert_eq!(iter.next(), None);            // 已耗尽
    assert_eq!(iter.next_back(), None);       // 从后也取不到
}

深度理解：这个不变式确保了迭代器状态的一致性。无论从哪端消费元素，迭代器内部的"剩余范围"都在同步缩小。

标准库中的双端迭代器

Vec 和 Slice

最常见的双端迭代器实现来自于切片：

fn slice_double_ended() {
    let numbers = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
    
    // 同时从两端处理数据
    let mut iter = numbers.iter();
    let mut front_sum = 0;
    let mut back_sum = 0;
    
    while let (Some(&front), Some(&back)) = (iter.next(), iter.next_back()) {
        front_sum += front;
        back_sum += back;
        if front == back {
            // 奇数长度时，中间元素会被处理两次
            break;
        }
    }
    
    println!("Front sum: {}, Back sum: {}", front_sum, back_sum);
}

Range 类型

fn range_reverse() {
    let range = 1..=10;
    
    // 利用双端特性实现反向迭代
    for i in range.rev() {
        print!("{} ", i); // 10 9 8 7 6 5 4 3 2 1
    }
}

专业思考：rev() 方法正是建立在 DoubleEndedIterator 基础上的。它返回一个 Rev 适配器，将 next_back() 映射为 next()，实现零成本的反向迭代。

实战应用场景

场景一：回文检测

fn is_palindrome_efficient(s: &str) -> bool {
    let chars: Vec<char> = s.chars().collect();
    let mut iter = chars.iter();
    
    while let (Some(&front), Some(&back)) = (iter.next(), iter.next_back()) {
        if front != back {
            return false;
        }
    }
    true
}

fn palindrome_example() {
    assert!(is_palindrome_efficient("racecar"));
    assert!(!is_palindrome_efficient("hello"));
    assert!(is_palindrome_efficient("a"));
    assert!(is_palindrome_efficient(""));
}

算法优势：传统方法需要两个索引指针，而双端迭代器将这种模式抽象化，代码更简洁且不易出错。时间复杂度仍为 O(n)，但常数因子更优。

场景二：双指针技巧

fn two_sum_sorted(numbers: &[i32], target: i32) -> Option<(usize, usize)> {
    let mut iter = numbers.iter().enumerate();
    let mut left_pos = 0;
    let mut right_pos = numbers.len() - 1;
    
    while left_pos < right_pos {
        let sum = numbers[left_pos] + numbers[right_pos];
        
        match sum.cmp(&target) {
            std::cmp::Ordering::Equal => return Some((left_pos, right_pos)),
            std::cmp::Ordering::Less => left_pos += 1,
            std::cmp::Ordering::Greater => right_pos -= 1,
        }
    }
    None
}

// 使用双端迭代器的更函数式的版本
fn two_sum_functional(numbers: &[i32], target: i32) -> Option<(i32, i32)> {
    let mut iter = numbers.iter().copied();
    let mut left = iter.next()?;
    let mut right = iter.next_back()?;
    
    loop {
        match (left + right).cmp(&target) {
            std::cmp::Ordering::Equal => return Some((left, right)),
            std::cmp::Ordering::Less => {
                left = iter.next()?;
            }
            std::cmp::Ordering::Greater => {
                right = iter.next_back()?;
            }
        }
    }
}

设计权衡：函数式版本更优雅，但索引版本在需要返回位置时更实用。这体现了工具选择的情境依赖性。

场景三：交替处理

fn alternating_merge<T: Clone>(left: &[T], right: &[T]) -> Vec<T> {
    let mut result = Vec::with_capacity(left.len() + right.len());
    let mut left_iter = left.iter();
    let mut right_iter = right.iter();
    
    loop {
        match (left_iter.next(), right_iter.next_back()) {
            (Some(l), Some(r)) => {
                result.push(l.clone());
                result.push(r.clone());
            }
            (Some(l), None) => {
                result.push(l.clone());
                result.extend(left_iter.cloned());
                break;
            }
            (None, Some(r)) => {
                result.push(r.clone());
                result.extend(right_iter.rev().cloned());
                break;
            }
            (None, None) => break,
        }
    }
    result
}

fn merge_example() {
    let a = vec![1, 2, 3, 4];
    let b = vec![10, 20, 30];
    let merged = alternating_merge(&a, &b);
    println!("{:?}", merged); // [1, 30, 2, 20, 3, 10, 4]
}

创新思路：从左侧序列头部取，从右侧序列尾部取，创造出独特的合并模式。这种技巧在数据处理和算法竞赛中很有用。

自定义双端迭代器

实现循环缓冲区迭代器

struct CircularBuffer<T> {
    data: Vec<T>,
    read_pos: usize,
    write_pos: usize,
    len: usize,
}

impl<T> CircularBuffer<T> {
    fn new(capacity: usize) -> Self {
        CircularBuffer {
            data: Vec::with_capacity(capacity),
            read_pos: 0,
            write_pos: 0,
            len: 0,
        }
    }
    
    fn iter(&self) -> CircularIter<T> {
        CircularIter {
            buffer: self,
            front: 0,
            back: self.len,
        }
    }
}

struct CircularIter<'a, T> {
    buffer: &'a CircularBuffer<T>,
    front: usize,
    back: usize,
}

impl<'a, T> Iterator for CircularIter<'a, T> {
    type Item = &'a T;
    
    fn next(&mut self) -> Option<Self::Item> {
        if self.front >= self.back {
            return None;
        }
        
        let idx = (self.buffer.read_pos + self.front) % self.buffer.data.capacity();
        self.front += 1;
        self.buffer.data.get(idx)
    }
}

impl<'a, T> DoubleEndedIterator for CircularIter<'a, T> {
    fn next_back(&mut self) -> Option<Self::Item> {
        if self.front >= self.back {
            return None;
        }
        
        self.back -= 1;
        let idx = (self.buffer.read_pos + self.back) % self.buffer.data.capacity();
        self.buffer.data.get(idx)
    }
}

实现要点：

维护 front 和 back 两个游标
确保 front >= back 时迭代器耗尽
正确处理循环缓冲区的环形索引计算

链表的双端迭代

use std::collections::LinkedList;

fn linkedlist_double_ended() {
    let mut list = LinkedList::new();
    list.push_back(1);
    list.push_back(2);
    list.push_back(3);
    list.push_back(4);
    list.push_back(5);
    
    let mut iter = list.iter();
    
    // 从两端同时消费
    while let (Some(&front), Some(&back)) = (iter.next(), iter.next_back()) {
        println!("Front: {}, Back: {}", front, back);
        if front == back {
            break;
        }
    }
}

性能考量：链表天然支持双端操作，其 next_back() 同样是 O(1) 复杂度，这是链表相对于数组的优势之一。

高级技巧与组合器

rfold：从右向左折叠

fn rfold_demonstration() {
    let numbers = vec![1, 2, 3, 4, 5];
    
    // 从右向左累积字符串
    let result = numbers.iter()
        .rfold(String::new(), |mut acc, &num| {
            if !acc.is_empty() {
                acc.push_str(", ");
            }
            acc.push_str(&num.to_string());
            acc
        });
    
    println!("{}", result); // "5, 4, 3, 2, 1"
}

函数式威力：rfold 是 fold 的反向版本，基于 DoubleEndedIterator 实现。它在处理后缀表达式或构建反向数据结构时非常有用。

rev() 的链式调用

fn rev_combinations() {
    let data = vec![1, 2, 3, 4, 5];
    
    // 过滤后反向
    let result: Vec<_> = data.iter()
        .filter(|&&x| x % 2 == 0)
        .rev()
        .collect();
    
    println!("{:?}", result); // [4, 2]
    
    // 映射后反向
    let squares: Vec<_> = data.iter()
        .map(|&x| x * x)
        .rev()
        .collect();
    
    println!("{:?}", squares); // [25, 16, 9, 4, 1]
}

组合威力：只要中间的适配器保持了 DoubleEndedIterator 特性（如 filter、map），就可以在链式调用的任意位置使用 rev()。

性能分析与陷阱

性能特性

use std::time::Instant;

fn performance_comparison() {
    let data: Vec<i32> = (0..10_000_000).collect();
    
    // 正向迭代
    let start = Instant::now();
    let sum1: i32 = data.iter().sum();
    let forward_time = start.elapsed();
    
    // 反向迭代
    let start = Instant::now();
    let sum2: i32 = data.iter().rev().sum();
    let backward_time = start.elapsed();
    
    println!("Forward: {:?}, Backward: {:?}", forward_time, backward_time);
    assert_eq!(sum1, sum2);
}

性能结论：对于连续内存（Vec、数组），正向和反向迭代性能几乎相同，差异通常在噪声范围内。现代 CPU 的预取机制对两种方向都很友好。

常见陷阱

fn pitfall_example() {
    let data = vec![1, 2, 3, 4, 5];
    let mut iter = data.iter();
    
    // 陷阱：混合使用 next 和 next_back 时的逻辑错误
    println!("{:?}", iter.next());      // Some(1)
    println!("{:?}", iter.next_back()); // Some(5)
    
    // 此时剩余元素是 [2, 3, 4]
    let remaining: Vec<_> = iter.collect();
    println!("{:?}", remaining); // [2, 3, 4]
}

警示：混合使用两端迭代时，必须清楚理解迭代器的当前状态。建议在复杂逻辑中显式跟踪状态或使用单一方向。

最佳实践与设计模式

何时使用双端迭代器

算法需要两端访问：如回文检测、双指针技巧
需要反向遍历：使用 rev() 而非手动索引
构建对称数据结构：如从中心向两端扩展

何时避免

简单的单向遍历：额外的抽象增加复杂度
无法高效实现 next_back：如某些流式数据源
性能不是瓶颈时：优先考虑代码清晰度

设计模式：迭代器适配器

struct Interlaced<I: DoubleEndedIterator> {
    iter: I,
    from_front: bool,
}

impl<I: DoubleEndedIterator> Iterator for Interlaced<I> {
    type Item = I::Item;
    
    fn next(&mut self) -> Option<Self::Item> {
        let result = if self.from_front {
            self.iter.next()
        } else {
            self.iter.next_back()
        };
        self.from_front = !self.from_front;
        result
    }
}

fn interlaced_example() {
    let data = vec![1, 2, 3, 4, 5, 6];
    let interlaced = Interlaced {
        iter: data.into_iter(),
        from_front: true,
    };
    
    let result: Vec<_> = interlaced.collect();
    println!("{:?}", result); // [1, 6, 2, 5, 3, 4]
}

创新思维：这个适配器创造了独特的遍历模式，展示了双端迭代器的组合能力。

结语

DoubleEndedIterator 是 Rust 迭代器系统的一个精妙扩展，它在保持零成本抽象的同时，提供了强大的双向遍历能力。理解并善用这一特性，不仅能写出更优雅的代码，还能在特定场景下获得性能优势。记住：迭代器不仅是循环的替代品，更是一种思维方式——将数据处理抽象为一系列可组合的变换。当你开始思考"这个算法能否从两端处理"时，你已经掌握了双端迭代器的精髓。🚀

你对双端迭代器还有什么疑问？想了解更多关于其他高级迭代器 trait 如 ExactSizeIterator 或 FusedIterator 的内容吗？😊

## 引言

在 Rust 的迭代器生态中，`DoubleEndedIterator` 是一个容易被忽视但功能强大的 trait。它不仅支持从前向后遍历，还能从后向前遍历，这种双向能力在特定场景下能极大简化算法实现。本文将深入探讨双端迭代器的设计哲学、实现机制和实战应用，帮助你掌握这一高级特性。🎯

## 核心概念与设计哲学

### Trait 定义

```rust
pub trait DoubleEndedIterator: Iterator {
fn next_back(&mut self) -> Option<Self::Item>;
}
```

**设计洞察**：`DoubleEndedIterator` 继承自 `Iterator`，意味着它必须同时支持 `next()` 和 `next_back()`。这种设计体现了 Rust 的组合性原则——在基础能力上叠加高级特性。

### 语义约束

双端迭代器必须满足一个重要不变式：从前向后和从后向前的遍历最终会在中间相遇，且不会遗漏或重复元素。

```rust
fn invariant_demonstration() {
let data = vec![1, 2, 3, 4, 5];
let mut iter = data.iter();

assert_eq!(iter.next(), Some(&1)); // 从前取
assert_eq!(iter.next_back(), Some(&5)); // 从后取
assert_eq!(iter.next(), Some(&2)); // 从前取
assert_eq!(iter.next_back(), Some(&4)); // 从后取
assert_eq!(iter.next(), Some(&3)); // 最后一个元素
assert_eq!(iter.next(), None); // 已耗尽
assert_eq!(iter.next_back(), None); // 从后也取不到
}
```

**深度理解**：这个不变式确保了迭代器状态的一致性。无论从哪端消费元素，迭代器内部的"剩余范围"都在同步缩小。

## 标准库中的双端迭代器

### Vec 和 Slice

最常见的双端迭代器实现来自于切片：

```rust
fn slice_double_ended() {
let numbers = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

// 同时从两端处理数据
let mut iter = numbers.iter();
let mut front_sum = 0;
let mut back_sum = 0;

while let (Some(&front), Some(&back)) = (iter.next(), iter.next_back()) {
front_sum += front;
back_sum += back;
if front == back {
// 奇数长度时，中间元素会被处理两次
break;
}
}

println!("Front sum: {}, Back sum: {}", front_sum, back_sum);
}
```

### Range 类型

```rust
fn range_reverse() {
let range = 1..=10;

// 利用双端特性实现反向迭代
for i in range.rev() {
print!("{} ", i); // 10 9 8 7 6 5 4 3 2 1
}
}
```

**专业思考**：`rev()` 方法正是建立在 `DoubleEndedIterator` 基础上的。它返回一个 `Rev` 适配器，将 `next_back()` 映射为 `next()`，实现零成本的反向迭代。

## 实战应用场景

### 场景一：回文检测

```rust
fn is_palindrome_efficient(s: &str) -> bool {
let chars: Vec<char> = s.chars().collect();
let mut iter = chars.iter();

while let (Some(&front), Some(&back)) = (iter.next(), iter.next_back()) {
if front != back {
return false;
}
}
true
}

fn palindrome_example() {
assert!(is_palindrome_efficient("racecar"));
assert!(!is_palindrome_efficient("hello"));
assert!(is_palindrome_efficient("a"));
assert!(is_palindrome_efficient(""));
}
```

**算法优势**：传统方法需要两个索引指针，而双端迭代器将这种模式抽象化，代码更简洁且不易出错。时间复杂度仍为 O(n)，但常数因子更优。

### 场景二：双指针技巧

```rust
fn two_sum_sorted(numbers: &[i32], target: i32) -> Option<(usize, usize)> {
let mut iter = numbers.iter().enumerate();
let mut left_pos = 0;
let mut right_pos = numbers.len() - 1;

while left_pos < right_pos {
let sum = numbers[left_pos] + numbers[right_pos];

match sum.cmp(&target) {
std::cmp::Ordering::Equal => return Some((left_pos, right_pos)),
std::cmp::Ordering::Less => left_pos += 1,
std::cmp::Ordering::Greater => right_pos -= 1,
}
}
None
}

// 使用双端迭代器的更函数式的版本
fn two_sum_functional(numbers: &[i32], target: i32) -> Option<(i32, i32)> {
let mut iter = numbers.iter().copied();
let mut left = iter.next()?;
let mut right = iter.next_back()?;

loop {
match (left + right).cmp(&target) {
std::cmp::Ordering::Equal => return Some((left, right)),
std::cmp::Ordering::Less => {
left = iter.next()?;
}
std::cmp::Ordering::Greater => {
right = iter.next_back()?;
}
}
}
}
```

**设计权衡**：函数式版本更优雅，但索引版本在需要返回位置时更实用。这体现了工具选择的情境依赖性。

### 场景三：交替处理

```rust
fn alternating_merge<T: Clone>(left: &[T], right: &[T]) -> Vec<T> {
let mut result = Vec::with_capacity(left.len() + right.len());
let mut left_iter = left.iter();
let mut right_iter = right.iter();

loop {
match (left_iter.next(), right_iter.next_back()) {
(Some(l), Some(r)) => {
result.push(l.clone());
result.push(r.clone());
}
(Some(l), None) => {
result.push(l.clone());
result.extend(left_iter.cloned());
break;
}
(None, Some(r)) => {
result.push(r.clone());
result.extend(right_iter.rev().cloned());
break;
}
(None, None) => break,
}
}
result
}

fn merge_example() {
let a = vec![1, 2, 3, 4];
let b = vec![10, 20, 30];
let merged = alternating_merge(&a, &b);
println!("{:?}", merged); // [1, 30, 2, 20, 3, 10, 4]
}
```

**创新思路**：从左侧序列头部取，从右侧序列尾部取，创造出独特的合并模式。这种技巧在数据处理和算法竞赛中很有用。

## 自定义双端迭代器

### 实现循环缓冲区迭代器

```rust
struct CircularBuffer<T> {
data: Vec<T>,
read_pos: usize,
write_pos: usize,
len: usize,
}

impl<T> CircularBuffer<T> {
fn new(capacity: usize) -> Self {
CircularBuffer {
data: Vec::with_capacity(capacity),
read_pos: 0,
write_pos: 0,
len: 0,
}
}

fn iter(&self) -> CircularIter<T> {
CircularIter {
buffer: self,
front: 0,
back: self.len,
}
}
}

struct CircularIter<'a, T> {
buffer: &'a CircularBuffer<T>,
front: usize,
back: usize,
}

impl<'a, T> Iterator for CircularIter<'a, T> {
type Item = &'a T;

fn next(&mut self) -> Option<Self::Item> {
if self.front >= self.back {
return None;
}

let idx = (self.buffer.read_pos + self.front) % self.buffer.data.capacity();
self.front += 1;
self.buffer.data.get(idx)
}
}

impl<'a, T> DoubleEndedIterator for CircularIter<'a, T> {
fn next_back(&mut self) -> Option<Self::Item> {
if self.front >= self.back {
return None;
}

self.back -= 1;
let idx = (self.buffer.read_pos + self.back) % self.buffer.data.capacity();
self.buffer.data.get(idx)
}
}
```

**实现要点**：

1. 维护 `front` 和 `back` 两个游标
2. 确保 `front >= back` 时迭代器耗尽
3. 正确处理循环缓冲区的环形索引计算

### 链表的双端迭代

```rust
use std::collections::LinkedList;

fn linkedlist_double_ended() {
let mut list = LinkedList::new();
list.push_back(1);
list.push_back(2);
list.push_back(3);
list.push_back(4);
list.push_back(5);

let mut iter = list.iter();

// 从两端同时消费
while let (Some(&front), Some(&back)) = (iter.next(), iter.next_back()) {
println!("Front: {}, Back: {}", front, back);
if front == back {
break;
}
}
}
```

**性能考量**：链表天然支持双端操作，其 `next_back()` 同样是 O(1) 复杂度，这是链表相对于数组的优势之一。

## 高级技巧与组合器

### rfold：从右向左折叠

```rust
fn rfold_demonstration() {
let numbers = vec![1, 2, 3, 4, 5];

// 从右向左累积字符串
let result = numbers.iter()
.rfold(String::new(), |mut acc, &num| {
if !acc.is_empty() {
acc.push_str(", ");
}
acc.push_str(&num.to_string());
acc
});

println!("{}", result); // "5, 4, 3, 2, 1"
}
```

**函数式威力**：`rfold` 是 `fold` 的反向版本，基于 `DoubleEndedIterator` 实现。它在处理后缀表达式或构建反向数据结构时非常有用。

### rev() 的链式调用

```rust
fn rev_combinations() {
let data = vec![1, 2, 3, 4, 5];

// 过滤后反向
let result: Vec<_> = data.iter()
.filter(|&&x| x % 2 == 0)
.rev()
.collect();

println!("{:?}", result); // [4, 2]

// 映射后反向
let squares: Vec<_> = data.iter()
.map(|&x| x * x)
.rev()
.collect();

println!("{:?}", squares); // [25, 16, 9, 4, 1]
}
```

**组合威力**：只要中间的适配器保持了 `DoubleEndedIterator` 特性（如 `filter`、`map`），就可以在链式调用的任意位置使用 `rev()`。

## 性能分析与陷阱

### 性能特性

```rust
use std::time::Instant;

fn performance_comparison() {
let data: Vec<i32> = (0..10_000_000).collect();

// 正向迭代
let start = Instant::now();
let sum1: i32 = data.iter().sum();
let forward_time = start.elapsed();

// 反向迭代
let start = Instant::now();
let sum2: i32 = data.iter().rev().sum();
let backward_time = start.elapsed();

println!("Forward: {:?}, Backward: {:?}", forward_time, backward_time);
assert_eq!(sum1, sum2);
}
```

**性能结论**：对于连续内存（Vec、数组），正向和反向迭代性能几乎相同，差异通常在噪声范围内。现代 CPU 的预取机制对两种方向都很友好。

### 常见陷阱

```rust
fn pitfall_example() {
let data = vec![1, 2, 3, 4, 5];
let mut iter = data.iter();

// 陷阱：混合使用 next 和 next_back 时的逻辑错误
println!("{:?}", iter.next()); // Some(1)
println!("{:?}", iter.next_back()); // Some(5)

// 此时剩余元素是 [2, 3, 4]
let remaining: Vec<_> = iter.collect();
println!("{:?}", remaining); // [2, 3, 4]
}
```

**警示**：混合使用两端迭代时，必须清楚理解迭代器的当前状态。建议在复杂逻辑中显式跟踪状态或使用单一方向。

## 最佳实践与设计模式

### 何时使用双端迭代器

1. **算法需要两端访问**：如回文检测、双指针技巧
2. **需要反向遍历**：使用 `rev()` 而非手动索引
3. **构建对称数据结构**：如从中心向两端扩展

### 何时避免

1. **简单的单向遍历**：额外的抽象增加复杂度
2. **无法高效实现 next\_back**：如某些流式数据源
3. **性能不是瓶颈时**：优先考虑代码清晰度

### 设计模式：迭代器适配器

```rust
struct Interlaced<I: DoubleEndedIterator> {
iter: I,
from_front: bool,
}

impl<I: DoubleEndedIterator> Iterator for Interlaced<I> {
type Item = I::Item;

fn next(&mut self) -> Option<Self::Item> {
let result = if self.from_front {
self.iter.next()
} else {
self.iter.next_back()
};
self.from_front = !self.from_front;
result
}
}

fn interlaced_example() {
let data = vec![1, 2, 3, 4, 5, 6];
let interlaced = Interlaced {
iter: data.into_iter(),
from_front: true,
};

let result: Vec<_> = interlaced.collect();
println!("{:?}", result); // [1, 6, 2, 5, 3, 4]
}
```

**创新思维**：这个适配器创造了独特的遍历模式，展示了双端迭代器的组合能力。

## 结语

`DoubleEndedIterator` 是 Rust 迭代器系统的一个精妙扩展，它在保持零成本抽象的同时，提供了强大的双向遍历能力。理解并善用这一特性，不仅能写出更优雅的代码，还能在特定场景下获得性能优势。记住：迭代器不仅是循环的替代品，更是一种思维方式——将数据处理抽象为一系列可组合的变换。当你开始思考"这个算法能否从两端处理"时，你已经掌握了双端迭代器的精髓。🚀

---

你对双端迭代器还有什么疑问？想了解更多关于其他高级迭代器 trait 如 `ExactSizeIterator` 或 `FusedIterator` 的内容吗？😊