Rust有序集合库small-ord-set的使用，高效存储和操作小型有序数据的轻量级解决方案

small-ord-set是一个基于排序SmallVec实现的集合数据结构。

安装

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

cargo add small-ord-set

或者在Cargo.toml中添加以下行：

small-ord-set = "0.1.3"

示例代码

下面是一个完整的使用示例：

use small_ord_set::SmallOrdSet;

fn main() {
    // 创建一个新的有序集合
    let mut set = SmallOrdSet::new();
    
    // 插入元素
    set.insert(5);
    set.insert(3);
    set.insert(8);
    set.insert(1);
    
    // 集合会自动保持有序
    println!("Set: {:?}", set); // 输出: Set: [1, 3, 5, 8]
    
    // 检查元素是否存在
    println!("Contains 3: {}", set.contains(&3)); // 输出: Contains 3: true
    println!("Contains 7: {}", set.contains(&7)); // 输出: Contains 7: false
    
    // 移除元素
    set.remove(&5);
    println!("After removal: {:?}", set); // 输出: After removal: [1, 3, 8]
    
    // 迭代元素
    println!("Iterating:");
    for item in set.iter() {
        println!("{}", item);
    }
    // 输出:
    // 1
    // 3
    // 8
    
    // 合并两个集合
    let mut other = SmallOrdSet::new();
    other.insert(2);
    other.insert(8);
    other.insert(10);
    
    set.union(&other);
    println!("After union: {:?}", set); // 输出: After union: [1, 2, 3, 8, 10]
}

特性

基于SmallVec实现，对于小型数据集特别高效
自动保持元素有序
提供标准集合操作：插入、删除、查找、合并等
内存紧凑，适合存储小型有序数据集

许可证

small-ord-set采用MIT或Apache-2.0许可证。

完整示例demo

下面是一个更完整的示例，展示更多small-ord-set的功能：

use small_ord_set::SmallOrdSet;

fn main() {
    // 初始化集合的几种方式
    let mut set1 = SmallOrdSet::new();
    set1.insert(10);
    set1.insert(20);
    
    // 从迭代器创建
    let mut set2: SmallOrdSet<u8> = vec![5, 3, 8, 1].into_iter().collect();
    println!("Set2: {:?}", set2);
    
    // 检查集合是否为空
    println!("Is empty: {}", set2.is_empty());
    
    // 获取集合长度
    println!("Length: {}", set2.len());
    
    // 获取最小和最大元素
    println!("Min: {:?}, Max: {:?}", set2.min(), set2.max());
    
    // 范围查找
    println!("Elements >=5: {:?}", set2.range(5..));
    
    // 差集操作
    let set3: SmallOrdSet<u8> = vec![1, 8].into_iter().collect();
    let diff = set2.difference(&set3);
    println!("Difference: {:?}", diff);
    
    // 交集操作
    let intersection = set2.intersection(&set3);
    println!("Intersection: {:?}", intersection);
    
    // 对称差集
    let sym_diff = set2.symmetric_difference(&set3);
    println!("Symmetric difference: {:?}", sym_diff);
    
    // 清空集合
    set2.clear();
    println!("After clear: {:?}", set2);
}

h691938207 1楼

Rust有序集合库small-ord-set的使用指南

介绍

small-ord-set是一个针对小型有序数据集优化的Rust集合库，它提供了高效的内存使用和快速的操作性能。这个库特别适合处理元素数量较少(通常在几十个以内)但需要保持有序的集合场景。

与标准库的BTreeSet相比，small-ord-set在小数据集上表现更优，因为它使用了更简单的线性存储结构，避免了B树的额外开销。

主要特性

专为小型数据集优化(通常<32个元素)
保持元素有序
低内存开销
提供类似标准库集合的API
支持no_std环境

使用方法

添加依赖

首先在Cargo.toml中添加依赖：

[dependencies]
small-ord-set = "0.1"

基本使用示例

use small_ord_set::SmallOrdSet;

fn main() {
    // 创建一个空集合
    let mut set = SmallOrdSet::<u32, 8>::new(); // 容量为8
    
    // 插入元素
    set.insert(5);
    set.insert(3);
    set.insert(8);
    set.insert(1);
    
    // 元素会自动排序
    println!("{:?}", set); // 输出: [1, 3, 5, 8]
    
    // 检查元素是否存在
    assert!(set.contains(&3));
    assert!(!set.contains(&10));
    
    // 移除元素
    set.remove(&5);
    println!("After removal: {:?}", set); // 输出: [1, 3, 8]
    
    // 遍历元素
    for num in &set {
        println!("{}", num);
    }
}

集合操作

use small_ord_set::SmallOrdSet;

fn main() {
    let mut set1 = SmallOrdSet::<_, 8>::from([1, 3, 5]);
    let set2 = SmallOrdSet::<_, 8>::from([2, 3, 4]);
    
    // 并集
    let union = set1.union(&set2);
    println!("Union: {:?}", union); // 输出: [1, 2, 3, 4, 5]
    
    // 交集
    let intersection = set1.intersection(&set2);
    println!("Intersection: {:?}", intersection); // 输出: [3]
    
    // 差集
    let difference = set1.difference(&set2);
    println!("Difference: {:?}", difference); // 输出: [1, 5]
}

性能优化示例

use small_ord_set::SmallOrdSet;

// 处理小型数据集时比BTreeSet更高效
fn process_small_dataset(items: &[u32]) -> SmallOrdSet极简示例：

```rust
use small_ord_set::SmallOrdSet;

fn main() {
    // 创建容量为5的集合
    let mut set = SmallOrdSet::<i32, 5>::new();
    
    // 插入元素
    set.insert(3);
    set.insert(1);
    set.insert(4);
    
    // 自动排序
    assert_eq!(set.iter().collect::<Vec<_>>(), vec![&1, &3, &4]);
}

高级示例：

use small_ord_set::SmallOrdSet;

fn main() {
    // 从数组直接创建集合
    let mut set = SmallOrdSet::<_, 10>::from([5, 2, 8, 1, 3]);
    
    // 范围查询
    println!("Range 2-5:");
    for num in set.range(2..=5) {
        println!("{}", num); // 输出 2, 3, 5
    }
    
    // 集合运算
    let other = SmallOrdSet::<_, 10>::from([3, 5, 7]);
    let intersection = set.intersection(&other);
    println!("Intersection: {:?}", intersection); // [3, 5]
    
    // 分裂集合
    let (left, right) = set.split_at(3);
    println!("Left: {:?}, Right: {:?}", left, right);
}

实际应用示例：

use small_ord_set::SmallOrdSet;

// 处理游戏中的小规模物品集合
struct GameItem {
    id: u32,
    name: String,
}

fn main() {
    // 创建物品集合(容量20)
    let mut inventory = SmallOrdSet::<GameItem, 20>::new();
    
    // 添加物品(按id排序)
    inventory.insert(GameItem { id: 3, name: "Sword".into() });
    inventory.insert(GameItem { id: 1, name: "Potion".into() });
    
    // 检查物品是否存在
    if inventory.iter().any(|item| item.id == 3) {
        println!("Found sword!");
    }
}