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在处理泛型和特质约束方面的强大功能，使我们能够编写适用于任何可比较类型的代码，这在实际项目中非常有价值。

相关推荐
AskHarries9 小时前
做国内还是出海
后端
YikNjy9 小时前
break和continue
java·开发语言·算法
日月云棠9 小时前
10 Integer —— 最常用的整数包装类深度解析
java·后端
大鸡腿同学9 小时前
大模型为何总 “胡说八道”？做完 RAG 知识库，我看懂了它的底层逻辑
后端
秋99 小时前
java项目中cpu飙升排查及解决方法
java·开发语言
野生技术架构师9 小时前
牛客网2026最新大厂Java高频面试题精选（附标准答案）
java·开发语言
PH = 79 小时前
JAVA的SPI机制
java·开发语言
一 乐9 小时前
高校实习信息发布网站|基于Spring Boot的高校实习信息发布网站的设计与实现(源码+数据库+文档)
java·数据库·spring boot·后端·论文·毕设·高校实习信息发布网站
安久19 小时前
springboot图片上传至服务器本地保存
后端
IT猿手9 小时前
多目标优化算法：多目标蛇优化算法（Multiple Objective Snake Optimizer，MOSO）（提供MATLAB代码）
开发语言·算法·matlab·动态路径规划·光伏模型参数估计
热门推荐
01GitHub 镜像站点02【踩坑记录 | 第一篇】微软商店无法使用时，如何手动安装 OpenAI Codex？附`.msix`文件系统错误解决方法03【AI】2026 年具身智能模型和世界模型总结04DeepSeek V4 + Claude Code thinking mode 400 错误修复方案05Codex 接入 DeepSeek API 完整配置文档06裂开！ChatGPT 居然开始要手机号验证，附详细解决方法07CC-Switch & Claude 基于 Linux 服务器安装使用指南08几个好用的ip纯净度检测网站09API Key 登录 Codex 也能用插件了，还支持会话删除和导出10CC-Switch 全平台下载、安装与使用全指南（Windows/macOS/Linux）