Rust有序迭代器扩展库ordered_iter使用指南

ordered_iter是一个Rust库，它为迭代器提供了稳定的顺序保证和额外的功能扩展，特别适合需要确定性迭代顺序的场景。

主要特性

• 保证迭代顺序的稳定性
• 提供额外的迭代器组合操作
• 支持确定性哈希和比较操作
• 适用于需要稳定迭代顺序的算法和数据结构

安装

在Cargo.toml中添加依赖：

[dependencies]
ordered_iter = "0.1"

基本用法

创建有序迭代器

use ordered_iter::{OrderedIterator, ordered};

let vec = vec![3, 1, 4, 1, 5];
let ordered = ordered(vec);
for num in ordered {
    println!("{}", num); // 保证按3,1,4,1,5的顺序输出
}

有序集合操作

use ordered_iter::{ordered, OrderedIteratorExt};

let a = ordered(vec![1, 2, 3]);
let b = ordered(vec![2, 3, 4]);

// 有序并集
let union = a.ordered_union(b);
assert_eq!(union.collect::<Vec<_>>(), vec![1, 2, 3, 4]);

// 有序交集
let a = ordered(vec![1, 2, 3]);
let b = ordered(vec![2, 3, 4]);
let intersection = a.ordered_intersection(b);
assert_eq!(intersection.collect::<Vec<_>>(), vec![2, 3]);

确定性哈希

use ordered_iter::ordered;
use std::collections::hash_map::DefaultHasher;
use std::hash::{Hash, Hasher};

let iter1 = ordered(vec![1, 2, 3]);
let iter2 = ordered(vec![1, 2, 3]);

let mut hasher1 = DefaultHasher::new();
let mut hasher2 = DefaultHasher::new();

iter1.hash(&mut hasher1);
iter2.hash(&mut hasher2);

assert_eq!(hasher1.finish(), hasher2.finish());

高级用法

自定义顺序迭代器

use ordered_iter::{OrderedIteratorExt, ordered};

struct Person {
    name: String,
    age: u32,
}

let people = vec![
    Person { name: "Alice".into(), age: 30 },
    Person { name: "Bob".into(), age: 25 },
    Person { name: "Charlie".into(), age: 35 },
];

// 按年龄排序的迭代器
let by_age = ordered(people).ordered_by(|p| p.age);
for person in by_age {
    println!("{}: {}", person.name, person.age);
    // 保证按25,30,35的顺序输出
}

有序分组

use ordered_iter::{ordered, OrderedIteratorExt};

let numbers = vec![1, 2, 3, 4, 5, 6, 7, 8, 9];

// 按奇偶分组
let grouped = ordered(numbers).ordered_group_by(|&n| n % 2 == 0);

for (is_even, group) in grouped {
    println!("{}: {:?}", is_even, group.collect::<Vec<_>>());
    // 保证先输出false组，再输出true组
}

完整示例代码

use ordered_iter::{ordered, OrderedIterator, OrderedIteratorExt};
use std::collections::hash_map::DefaultHasher;
use std::hash::{Hash, Hasher};

fn main() {
    // 示例1: 基本有序迭代
    println!("--- 基本有序迭代示例 ---");
    basic_ordered_iteration();
    
    // 示例2: 有序集合操作
    println!("\n--- 有序集合操作示例 ---");
    ordered_set_operations();
    
    // 示例3: 确定性哈希
    println!("\n--- 确定性哈希示例 ---");
    deterministic_hashing();
    
    // 示例4: 自定义顺序
    println!("\n--- 自定义顺序示例 ---");
    custom_ordering();
    
    // 示例5: 有序分组
    println!("\n--- 有序分组示例 ---");
    ordered_grouping();
}

fn basic_ordered_iteration() {
    let vec = vec![3, 1, 4, 1, 5];
    let ordered = ordered(vec);
    for num in ordered {
        print!("{} ", num); // 输出: 3 1 4 1 5
    }
}

fn ordered_set_operations() {
    let a = ordered(vec![1, 2, 3]);
    let b = ordered(vec![2, 3, 4]);
    
    // 并集
    let union = a.ordered_union(b);
    println!("并集: {:?}", union.collect::<Vec<_>>()); // [1, 2, 3, 4]
    
    // 交集
    let a = ordered(vec![1, 2, 3]);
    let b = ordered(vec![2, 3, 4]);
    let intersection = a.ordered_intersection(b);
    println!("交集: {:?}", intersection.collect::<Vec<_>>()); // [2, 3]
}

fn deterministic_hashing() {
    let iter1 = ordered(vec![1, 2, 3]);
    let iter2 = ordered(vec![1, 2, 3]);

    let mut hasher1 = DefaultHasher::new();
    let mut hasher2 = DefaultHasher::new();

    iter1.hash(&mut hasher1);
    iter2.hash(&mut hasher2);

    println!("哈希值1: {}", hasher1.finish());
    println!("哈希值2: {}", hasher2.finish());
    assert_eq!(hasher1.finish(), hasher2.finish());
}

fn custom_ordering() {
    #[derive(Debug)]
    struct Person {
        name: String,
        age: u32,
    }

    let people = vec![
        Person { name: "Alice".into(), age: 30 },
        Person { name: "Bob".into(), age: 25 },
        Person { name: "Charlie".into(), age: 35 },
    ];

    // 按年龄升序
    let by_age = ordered(people).ordered_by(|p| p.age);
    for person in by_age {
        println!("{:?}", person); // 按年龄25,30,35顺序输出
    }
}

fn ordered_grouping() {
    let numbers = vec![1, 2, 3, 4, 5, 6, 7, 8, 9];
    
    // 按奇偶分组
    let grouped = ordered(numbers).ordered_group_by(|&n| n % 2 == 0);
    
    for (is_even, group) in grouped {
        println!("偶数? {}: {:?}", is_even, group.collect::<Vec<_>>());
        // 先输出奇数组(false)，再输出偶数组(true)
    }
}

性能考虑

ordered_iter在保证顺序的同时会带来一些性能开销：

• 内存使用：可能需要缓存元素
• CPU开销：额外的顺序维护逻辑

在不需要顺序保证的场景下，使用标准迭代器可能更高效。

适用场景

• 需要确定性迭代顺序的算法
• 测试中需要可重复的结果
• 基于迭代顺序的哈希或比较操作
• 需要稳定顺序的组合操作(并集、交集等)