Rust 练习册 109：深入探索列表关系判断

星释2025-12-08 9:04

在数据处理和算法设计中，我们经常需要比较两个列表之间的关系。今天我们要探讨的是一个有趣而实用的问题：如何判断两个列表之间的包含关系。这个问题在实际应用中非常常见，比如在文本处理中查找子串、在数据验证中检查数据完整性，或者在集合操作中判断子集关系。通过Rust语言，我们将深入探索这个看似简单但内涵丰富的算法问题。

问题背景

在数学和计算机科学中，列表（或序列）之间的关系可以分为以下几种：

  1. 相等（Equal）：两个列表完全相同
  2. 子列表（Sublist）：第一个列表是第二个列表的连续子序列
  3. 超列表（Superlist）：第二个列表是第一个列表的连续子序列
  4. 不相等（Unequal）：两个列表没有包含关系

例如：

  • 1, 2, 3 和 1, 2, 3 是相等的
  • 1, 2 是 0, 1, 2, 3 的子列表
  • 0, 1, 2, 3 是 1, 2 的超列表
  • 1, 2, 3 和 3, 2, 1 是不相等的

问题描述

我们的任务是实现一个能够判断两个列表关系的函数：

rust 复制代码 
#[derive(Debug, PartialEq)]
pub enum Comparison {
    Equal,
    Sublist,
    Superlist,
    Unequal,
}

fn contains<T: PartialEq>(a: &[T], b: &[T]) -> bool {
    if a.len() < b.len() {
        return false;
    }
    if a.starts_with(b) {
        return true;
    }
    contains(&a[1..], b)
}

// fn contains<T: PartialEq>(a: &[T], b: &[T]) -> bool {
//     if a.len() < b.len() {
//         return false;
// //     }
//     for i in 0..a.len() {
//         if a[i..].starts_with(b) {
//             return true;
//         }
//     }
//     false
// }

pub fn sublist<T: PartialEq>(a: &[T], b: &[T]) -> Comparison {
    if a == b {
        return Comparison::Equal;
    } else if contains(a, b) {
        return Comparison::Superlist;
    } else if contains(b, a) {
        return Comparison::Sublist;
    }
    return Comparison::Unequal;
}

这个实现使用了递归的方式来检查一个列表是否包含另一个列表作为子序列。

算法解析

让我们逐步分析代码的各个部分：

Comparison枚举

rust 复制代码 
#[derive(Debug, PartialEq)]
pub enum Comparison {
    Equal,
    Sublist,
    Superlist,
    Unequal,
}

这个枚举定义了两个列表之间可能存在的四种关系，Debug和PartialEq派生特质使得我们可以打印和比较这些值。

contains函数

rust 复制代码 
fn contains<T: PartialEq>(a: &[T], b: &[T]) -> bool {
    if a.len() < b.len() {
        return false;
    }
    if a.starts_with(b) {
        return true;
    }
    contains(&a[1..], b)
}

这个函数检查列表a是否包含列表b作为连续子序列：

  1. 如果a比b短，那么a不可能包含b
  2. 如果a以b开头，则找到了匹配
  3. 否则，递归检查a的剩余部分是否包含b

这是一个经典的递归实现，每次递归都去掉a的第一个元素。

主函数sublist

rust 复制代码 
pub fn sublist<T: PartialEq>(a: &[T], b: &[T]) -> Comparison {
    if a == b {
        return Comparison::Equal;
    } else if contains(a, b) {
        return Comparison::Superlist;
    } else if contains(b, a) {
        return Comparison::Sublist;
    }
    return Comparison::Unequal;
}

主函数按照以下逻辑判断关系：

  1. 首先检查两个列表是否完全相等
  2. 然后检查a是否包含b（a是b的超列表）
  3. 接着检查b是否包含a（a是b的子列表）
  4. 如果以上都不满足，则两个列表不相等且无包含关系

测试案例详解

通过查看测试案例，我们可以更好地理解函数的行为：

rust 复制代码 
#[test]
fn empty_equals_empty() {
    let v: &[u32] = &[];

    assert_eq!(Comparison::Equal, sublist(&v, &v));
}

两个空列表是相等的。

rust 复制代码 
#[test]
fn test_empty_is_a_sublist_of_anything() {
    assert_eq!(Comparison::Sublist, sublist(&[], &['a', 's', 'd', 'f']));
}

空列表是任何列表的子列表，这符合数学定义。

rust 复制代码 
#[test]
fn test_anything_is_a_superlist_of_empty() {
    assert_eq!(Comparison::Superlist, sublist(&['a', 's', 'd', 'f'], &[]));
}

任何列表都是空列表的超列表。

rust 复制代码 
#[test]
fn test_1_is_not_2() {
    assert_eq!(Comparison::Unequal, sublist(&[1], &[2]));
}

不同的单元素列表既不相等也没有包含关系。

rust 复制代码 
#[test]
fn test_sublist_at_start() {
    assert_eq!(Comparison::Sublist, sublist(&[1, 2, 3], &[1, 2, 3, 4, 5]));
}

列表可以在另一个列表的开头作为子列表出现。

rust 复制代码 
#[test]
fn sublist_in_middle() {
    assert_eq!(Comparison::Sublist, sublist(&[4, 3, 2], &[5, 4, 3, 2, 1]));
}

子列表也可以出现在另一个列表的中间。

rust 复制代码 
#[test]
fn sublist_early_in_huge_list() {
    let huge: Vec<u32> = (1..1_000_000).collect();

    assert_eq!(Comparison::Sublist, sublist(&[3, 4, 5], &huge));
}

即使在大列表中，算法也能正确找到子列表。

性能优化版本

原实现使用递归，对于大列表可能会导致栈溢出。我们可以使用迭代方式优化：

rust 复制代码 
fn contains_iterative<T: PartialEq>(a: &[T], b: &[T]) -> bool {
    if b.is_empty() {
        return true;
    }
    
    if a.len() < b.len() {
        return false;
    }
    
    // 使用滑动窗口检查
    a.windows(b.len()).any(|window| window == b)
}

这个版本使用了Rust标准库的windows方法，更加简洁高效。

更完整的实现

结合两种方法的优点，我们可以得到一个更健壮的实现：

rust 复制代码 
#[derive(Debug, PartialEq)]
pub enum Comparison {
    Equal,
    Sublist,
    Superlist,
    Unequal,
}

fn contains<T: PartialEq>(a: &[T], b: &[T]) -> bool {
    // 空列表是任何列表的子列表
    if b.is_empty() {
        return true;
    }
    
    // 如果a比b短，则a不可能包含b
    if a.len() < b.len() {
        return false;
    }
    
    // 使用滑动窗口检查是否有匹配
    a.windows(b.len()).any(|window| window == b)
}

pub fn sublist<T: PartialEq>(a: &[T], b: &[T]) -> Comparison {
    // 首先检查是否相等
    if a == b {
        return Comparison::Equal;
    }
    
    // 检查a是否包含b（a是b的超列表）
    if contains(a, b) {
        return Comparison::Superlist;
    }
    
    // 检查b是否包含a（a是b的子列表）
    if contains(b, a) {
        return Comparison::Sublist;
    }
    
    // 否则两者不相等且无包含关系
    Comparison::Unequal
}

这个版本使用了windows方法和any迭代器适配器，更加高效且不会导致栈溢出。

Rust语言特性运用

在这个实现中，我们运用了多种Rust语言特性：

  1. 泛型编程: 使用T: PartialEq使函数适用于任何可比较的类型
  2. 切片操作: 使用\&\[T]处理列表的子序列
  3. 迭代器: 使用windows和any方法进行高效遍历
  4. 模式匹配: 通过枚举和条件判断处理不同情况
  5. 特质约束: 使用PartialEq特质确保元素可以比较
  6. 函数式编程: 使用高阶函数如any进行集合操作

算法复杂度分析

让我们分析不同实现的复杂度：

递归版本

  • 时间复杂度: O(n×m)，其中n是主列表长度，m是子列表长度
  • 空间复杂度: O(n)，由于递归调用栈

迭代版本

  • 时间复杂度: O(n×m)，最坏情况下需要检查每个位置
  • 空间复杂度: O(1)，只使用常量额外空间

实际应用场景

子列表比较在许多实际场景中都有应用：

  1. 文本处理: 在文本中查找子串或模式
  2. 生物信息学: 在DNA序列中查找特定模式
  3. 数据验证: 检查数据流中是否包含特定序列
  4. 游戏开发: 检查玩家输入是否匹配特定模式
  5. 日志分析: 在日志文件中查找特定事件序列
  6. 网络协议: 验证数据包是否包含特定头部信息

扩展功能

我们可以为这个系统添加更多功能：

rust 复制代码 
impl<T: PartialEq> Comparison {
    pub fn is_equal(&self) -> bool {
        matches!(self, Comparison::Equal)
    }
    
    pub fn is_sublist(&self) -> bool {
        matches!(self, Comparison::Sublist)
    }
    
    pub fn is_superlist(&self) -> bool {
        matches!(self, Comparison::Superlist)
    }
    
    pub fn is_unequal(&self) -> bool {
        matches!(self, Comparison::Unequal)
    }
}

// 查找所有匹配位置
pub fn find_all_positions<T: PartialEq>(a: &[T], b: &[T]) -> Vec<usize> {
    if b.is_empty() || a.len() < b.len() {
        return vec![];
    }
    
    a.windows(b.len())
        .enumerate()
        .filter_map(|(i, window)| if window == b { Some(i) } else { None })
        .collect()
}

与其他实现方式的比较

使用标准库方法

rust 复制代码 
pub fn sublist_std<T: PartialEq>(a: &[T], b: &[T]) -> Comparison {
    if a == b {
        Comparison::Equal
    } else if a.len() < b.len() {
        if b.windows(a.len()).any(|w| w == a) {
            Comparison::Sublist
        } else {
            Comparison::Unequal
        }
    } else {
        if a.windows(b.len()).any(|w| w == b) {
            Comparison::Superlist
        } else {
            Comparison::Unequal
        }
    }
}

使用自定义迭代器

rust 复制代码 
struct SublistIterator<'a, T> {
    slice: &'a [T],
    window_size: usize,
    index: usize,
}

impl<'a, T: PartialEq> SublistIterator<'a, T> {
    fn new(slice: &'a [T], window_size: usize) -> Self {
        Self {
            slice,
            window_size,
            index: 0,
        }
    }
}

impl<'a, T: PartialEq> Iterator for SublistIterator<'a, T> {
    type Item = &'a [T];
    
    fn next(&mut self) -> Option<Self::Item> {
        if self.index + self.window_size <= self.slice.len() {
            let result = &self.slice[self.index..self.index + self.window_size];
            self.index += 1;
            Some(result)
        } else {
            None
        }
    }
}

总结

通过这个练习，我们学习到了：

  1. 如何分析和实现列表关系判断算法
  2. 递归与迭代两种实现方式的优缺点
  3. Rust标准库中强大而高效的迭代器方法
  4. 泛型编程在创建可重用代码中的应用
  5. 算法复杂度分析的基本方法
  6. 实际应用场景和扩展功能

子列表比较问题虽然看似简单，但它涉及了算法设计、数据结构操作和性能优化等多个方面。通过不同的实现方式，我们可以看到解决问题可以有多种思路，每种思路都有其适用场景。

在实际编程中，选择合适的实现方式需要考虑数据规模、性能要求和代码可读性等因素。Rust语言的安全性和表达能力使得实现这类算法变得既安全又高效。通过这个练习，我们不仅掌握了算法本身，也加深了对Rust语言特性的理解。

这个练习还展示了Rust在处理泛型和特质约束方面的强大功能，使我们能够编写适用于任何可比较类型的代码，这在实际项目中非常有价值。

相关推荐
IT_陈寒1 小时前
Redis内存爆了，原来我漏掉了这个致命配置
前端·人工智能·后端
fliter2 小时前
最后一块拼图：用 bitvec 构造 IPv4 包，真正做出自己的 Ping
后端
fliter3 小时前
用 Rust 解析并生成 ICMP 包：checksum、nom 与 cookie-factory
后端
蝎子莱莱爱打怪3 小时前
XZLL-IM干货系列 03｜消息 ID 设计：一个 UUID 搞不定的事，我用两个 ID 解决了
后端·面试·开源
fliter3 小时前
从 panic 到 Result：用 Rust 重新整理一个 ping 项目的错误处理
后端
森蓝情丶3 小时前
我给 AI 搭了个法庭：一个前端仔的 LangGraph 实战全记录
前端·后端
JensCS猿3 小时前
从 Spring Boot 回看 SSM 框架：手动挡与自动挡的驾驶哲学
后端
爱勇宝3 小时前
干了近 8 年，一夜之间被裁：AI 时代，程序员最该害怕的不是 AI
前端·后端·程序员
科米米4 小时前
嵌入式日志模块
后端
血小溅4 小时前
三大 AI 编码框架深度对比：GSD vs OpenSpec vs Superpowers
人工智能·后端
热门推荐
012026年6月AI行业全景：从百模大战到Agent元年，这30天发生了什么？022026年6月AI大模型全景报告：GPT-5.6、Claude Opus 4.8、Gemini 3.5，中美AI三足鼎立谁主沉浮？032026 年 AI 编程工具终极横评：Cursor vs Claude Code vs Copilot vs Windsurf04【AI】2026 年具身智能模型和世界模型总结05GitHub 镜像站点06AI科技热点日报 | 2026年6月1日07AI一周事件 · 2026-06-03 至 2026-06-0908Claude Code、Codex、Cursor三分天下：2026年AI编程Agent生态全景剖析09上线仅72小时被强制下架：Claude Fable 5 的短命10Codex 下载安装指南：Windows 和 macOS 官方版下载