Rust迭代器排序扩展库iterator-sorted的使用，提供高效有序迭代器适配器和排序功能

Rust迭代器排序扩展库iterator-sorted的使用

iterator-sorted库提供了stable函数来检查一个Iterator是否已排序。

安装

在项目目录中运行以下Cargo命令：

cargo add iterator-sorted

或者在Cargo.toml中添加：

iterator-sorted = "0.2.0"

使用示例

下面是一个完整的使用示例，展示如何使用iterator-sorted库来检查迭代器是否排序：

use iterator_sorted::is_sorted;

fn main() {
    // 创建一个已排序的向量
    let sorted_vec = vec![1, 2, 3, 4, 5];
    
    // 检查是否已排序
    if is_sorted(sorted_vec.iter()) {
        println!("向量已排序");
    } else {
        println!("向量未排序");
    }
    
    // 创建一个未排序的向量
    let unsorted_vec = vec![5, 2, 1, 4, 3];
    
    // 检查是否已排序
    if is_sorted(unsorted_vec.iter()) {
        println!("向量已排序");
    } else {
        println!("向量未排序");
    }
}

更复杂的示例

use iterator_sorted::{is_sorted, is_sorted_by, is_sorted_by_key};
use std::cmp::Ordering;

fn main() {
    // 使用自定义比较函数检查排序
    let vec = vec![5.0, 3.5, 1.2];
    let is_descending = is_sorted_by(vec.iter(), |a, b| a.partial_cmp(b).unwrap_or(Ordering::Equal).reverse());
    println!("向量是否降序排序: {}", is_descending);
    
    // 使用key函数检查排序
    let people = vec![
        Person { name: "Alice".to_string(), age: 30 },
        Person { name: "Bob".to_string(), age: 25 },
        Person { name: "Charlie".to_string(), age: 20 },
    ];
    let is_age_sorted = is_sorted_by_key(people.iter(), |p| p.age);
    println!("人员是否按年龄排序: {}", is_age_sorted);
}

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

功能说明

iterator-sorted库提供以下主要功能：

  1. is_sorted() - 检查迭代器是否按升序排序
  2. is_sorted_by() - 使用自定义比较函数检查排序
  3. is_sorted_by_key() - 使用key提取函数检查排序

该库适用于需要验证数据是否按照预期排序的场景，特别是在处理来自外部源的数据或验证算法输出时非常有用。

完整示例demo

下面是一个更完整的示例，展示了iterator-sorted库的所有主要功能：

use iterator_sorted::{is_sorted, is_sorted_by, is_sorted_by_key};
use std::cmp::Ordering;

#[derive(Debug)]
struct Product {
    name: String,
    price: f64,
    quantity: u32,
}

fn main() {
    // 示例1：基本排序检查
    let nums = vec![1, 2, 3, 4, 5];
    println!("nums is sorted: {}", is_sorted(nums.iter()));
    
    // 示例2：降序排序检查
    let descending = vec![5, 4, 3, 2, 1];
    println!("descending is sorted: {}", is_sorted_by(descending.iter(), |a, b| b.cmp(a)));
    
    // 示例3：浮点数排序检查
    let floats = vec![1.1, 2.2, 3.3, f64::NAN];
    println!("floats is sorted: {}", is_sorted_by(floats.iter(), |a, b| a.partial_cmp(b).unwrap_or(Ordering::Equal)));
    
    // 示例4：复杂结构体排序检查
    let products = vec![
        Product { name: "Apple".to_string(), price: 1.99, quantity: 100 },
        Product { name: "Banana".to_string(), price: 0.99, quantity: 200 },
        Product { name: "Orange".to_string(), price: 1.49, quantity: 150 },
    ];
    
    // 检查是否按价格排序
    println!("products by price: {}", is_sorted_by_key(products.iter(), |p| p.price));
    
    // 检查是否按数量排序
    println!("products by quantity: {}", is_sorted_by_key(products.iter(), |p| p.quantity));
    
    // 使用自定义比较函数检查
    println!("products by name length: {}", 
        is_sorted_by(products.iter(), |a, b| a.name.len().cmp(&b.name.len())));
}

这个完整示例展示了：

  1. 基本排序检查
  2. 降序排序检查
  3. 处理浮点数(包括NAN)的特殊情况
  4. 对复杂结构体按不同字段进行排序检查
  5. 使用自定义比较函数检查排序

1 回复

Rust迭代器排序扩展库iterator-sorted使用指南

iterator-sorted是一个Rust库，为迭代器提供了排序相关的扩展功能，可以高效地创建有序迭代器或检查迭代器是否有序。

主要功能

  1. 提供有序迭代器适配器
  2. 提供排序功能
  3. 提供检查迭代器是否有序的方法

安装

在Cargo.toml中添加依赖：

[dependencies]
iterator-sorted = "0.1"

完整示例代码

以下是结合内容中所有示例的完整demo：

use iterator_sorted::{is_sorted, SortedIterator, SortedByIterator};
use itertools::Itertools;

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

fn main() {
    // 示例1: 基本排序
    let v = vec![3, 1, 4, 1, 5, 9];
    println!("Is sorted: {}", is_sorted(v.iter()));  // false
    
    let sorted_iter = v.iter().sorted();  // 创建排序后的迭代器
    println!("Sorted:");
    for x in sorted_iter {
        print!("{} ", x);  // 1 1 3 4 5 9
    }
    println!();

    // 示例2: 使用有序迭代器适配器
    let v = vec![5, 2, 8, 1, 3];
    let sorted = v.iter().sorted();
    
    println!("Min: {:?}", sorted.clone().min());  // Some(1)
    println!("Max: {:?}", sorted.clone().max());  // Some(8)
    
    // 合并两个有序迭代器
    let v2 = vec![4, 6, 7];
    let merged = sorted.merge(v2.iter().sorted());
    println!("Merged:");
    for x in merged {
        print!("{} ", x);  // 1 2 3 4 5 6 7 8
    }
    println!();

    // 示例3: 自定义排序
    let people = vec![
        Person { name: "Alice".to_string(), age: 30 },
        Person { name: "Bob".to_string(), age: 25 },
        Person { name: "Charlie".to_string(), age: 35 },
    ];
    
    // 按年龄排序
    println!("Sorted by age:");
    let by_age = people.iter().sorted_by(|a, b| a.age.cmp(&b.age));
    for person in by_age {
        println!("{:?}", person);  // Bob(25), Alice(30), Charlie(35)
    }
    
    // 按名字排序
    println!("Sorted by name:");
    let by_name = people.iter().sorted_by_key(|p| &p.name);
    for person in by_name {
        println!("{:?}", person);  // Alice, Bob, Charlie
    }

    // 示例4: 检查有序性
    let sorted_vec = vec![1, 2, 3, 4, 5];
    let unsorted_vec = vec![1, 3, 2, 4, 5];
    let descending = vec![5, 4, 3, 2, 1];
    
    println!("sorted is sorted: {}", is_sorted(sorted_vec.iter()));  // true
    println!("unsorted is sorted: {}", is_sorted(unsorted_vec.iter()));  // false
    println!("descending is sorted (ascending check): {}", is_sorted(descending.iter()));  // false
    println!("descending is sorted (descending check): {}", is_sorted(descending.iter().rev()));  // true
}

性能特点

  1. 惰性求值：只在需要时排序
  2. 高效合并：合并两个有序迭代器的时间复杂度为O(n)
  3. 最小内存使用：避免不必要的内存分配

适用场景

  • 需要处理大型数据集但不想一次性全部排序
  • 需要合并多个已排序的数据流
  • 需要验证数据是否已排序
  • 需要延迟排序操作直到真正需要时

这个库特别适合处理大型数据集或需要高效内存使用的场景，因为它提供了惰性排序和操作的能力。

回到顶部