Rust范围集合处理库range-collections的使用指南

简介

range-collections是一个专门用于处理范围集合的Rust库，提供了高效的范围操作和集合运算功能。该库特别适合处理区间合并、交集计算、差集操作等场景，在数值范围处理、日程安排、资源分配等应用中非常实用。

主要特性

• 范围合并与规范化
• 集合运算（并集、交集、差集）
• 范围查询与包含检测
• 内存高效的范围存储
• 迭代器支持

安装方法

在Cargo.toml中添加依赖：

[dependencies]
range-collections = "0.3"

基本使用方法

创建范围集合

use range_collections::{RangeSet, RangeSet2};

// 创建空的范围集合
let mut set = RangeSet2::new();

// 添加单个范围
set.insert(0..10);

// 添加多个范围
set.insert(20..30);
set.insert(40..50);

范围合并操作

use range_collections::RangeSet2;

let mut set = RangeSet2::new();
set.insert(0..10);
set.insert(5..15); // 自动合并重叠范围

println!("合并后的范围: {:?}", set);
// 输出: [0..15)

集合运算示例

use range_collections::RangeSet2;

// 创建两个范围集合
let mut set1 = RangeSet2::new();
set1.insert(0..20);
set1.insert(30..40);

let mut set2 = RangeSet2::new();
set2.insert(10..25);
set2.insert(35..45);

// 求交集
let intersection = set1.intersection(&set2);
println!("交集: {:?}", intersection);
// 输出: [10..20), [35..40)

// 求并集
let union = set1.union(&set2);
println!("并集: {:?}", union);
// 输出: [0..25), [30..45)

// 求差集
let difference = set1.difference(&set2);
println!("差集: {:?}", difference);
// 输出: [0..10), [30..35)

范围查询

use range_collections::RangeSet2;

let mut set = RangeSet2::new();
set.insert(0..10);
set.insert(20..30);

// 检查是否包含某个值
assert!(set.contains(5));
assert!(!set.contains(15));

// 检查是否包含整个范围
assert!(set.contains_range(2..8));
assert!(!set.contains_range(5..15));

迭代范围

use range_collections::RangeSet2;

let mut set = RangeSet2::new();
set.insert(0..5);
set.insert(10..15);

// 迭代所有范围
for range in set.iter() {
    println!("范围: {:?}", range);
}

// 获取所有不连续的范围段
let gaps = set.gaps();
for gap in gaps.iter() {
    println!("间隔: {:?}", gap);
}

完整示例demo

use range_collections::RangeSet2;

fn main() {
    // 示例1：创建和基本操作
    println!("=== 示例1：创建和基本操作 ===");
    let mut set = RangeSet2::new();
    
    // 添加多个范围
    set.insert(0..10);
    set.insert(20..30);
    set.insert(40..50);
    println!("初始范围集合: {:?}", set);
    
    // 添加重叠范围，测试自动合并
    set.insert(5..15);
    println!("合并后的范围集合: {:?}", set);
    
    // 示例2：集合运算
    println!("\n=== 示例2：集合运算 ===");
    let mut set_a = RangeSet2::new();
    set_a.insert(0..20);
    set_a.insert(30..40);
    
    let mut set_b = RangeSet2::new();
    set_b.insert(10..25);
    set_b.insert(35..45);
    
    // 求交集
    let intersection = set_a.intersection(&set_b);
    println!("集合A: {:?}", set_a);
    println!("集合B: {:?}", set_b);
    println!("交集: {:?}", intersection);
    
    // 求并集
    let union = set_a.union(&set_b);
    println!("并集: {:?}", union);
    
    // 求差集
    let difference = set_a.difference(&set_b);
    println!("差集: {:?}", difference);
    
    // 示例3：范围查询
    println!("\n=== 示例3：范围查询 ===");
    let query_set = RangeSet2::from(vec![0..10, 20..30]);
    
    // 检查单个值
    println!("包含数字5: {}", query_set.contains(5));
    println!("包含数字15: {}", query_set.contains(15));
    
    // 检查范围
    println!("包含范围2..8: {}", query_set.contains_range(2..8));
    println!("包含范围5..15: {}", query_set.contains_range(5..15));
    
    // 示例4：迭代器使用
    println!("\n=== 示例4：迭代器使用 ===");
    let iter_set = RangeSet2::from(vec![0..5, 10..15, 20..25]);
    
    println!("所有范围:");
    for range in iter_set.iter() {
        println!("  {:?}", range);
    }
    
    println!("所有间隔:");
    for gap in iter_set.gaps().iter() {
        println!("  {:?}", gap);
    }
    
    // 示例5：实际应用 - 时间区间管理
    println!("\n=== 示例5：时间区间管理 ===");
    let mut schedule = RangeSet2::new();
    
    // 添加已预订的时间段（以分钟为单位）
    schedule.insert(60..120);   // 10:00-11:00
    schedule.insert(180..240);  // 13:00-14:00
    
    // 检查新的时间段是否可用
    let new_booking = 100..160; // 10:40-13:20
    if schedule.intersection(&RangeSet2::from(vec![new_booking])).is_empty() {
        println!("时间段可用，可以预订");
    } else {
        println!("时间段已被占用，请选择其他时间");
    }
}

性能特点

range-collections使用平衡树结构存储范围，确保以下操作的高效性：

• 插入和删除：O(log n)
• 范围查询：O(log n + k)，其中k是结果数量
• 集合运算：O(n log n)

实际应用场景

1. 时间区间管理：会议日程安排、资源预订系统
2. 数值范围处理：价格区间过滤、数值分段统计
3. 空间分区：地理区域划分、内存地址管理
4. 数据压缩：连续值的压缩存储

注意事项

• 范围默认使用左闭右开区间 [start, end)
• 支持所有实现了Ord trait的类型
• 空范围会被自动忽略
• 反向范围（end < start）会导致panic

这个库为Rust开发者提供了强大而高效的范围处理能力，特别适合需要处理复杂区间操作的应用程序。