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

在数据处理和算法设计中，我们经常需要比较两个列表之间的关系。今天我们要探讨的是一个有趣而实用的问题：如何判断两个列表之间的包含关系。这个问题在实际应用中非常常见，比如在文本处理中查找子串、在数据验证中检查数据完整性，或者在集合操作中判断子集关系。通过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] 是不相等的

问题描述

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

#[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枚举

#[derive(Debug, PartialEq)]
pub enum Comparison {
    Equal,
    Sublist,
    Superlist,
    Unequal,
}

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

contains函数

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

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. 如果以上都不满足，则两个列表不相等且无包含关系

测试案例详解

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

#[test]
fn empty_equals_empty() {
    let v: &[u32] = &[];

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

两个空列表是相等的。

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

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

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

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

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

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

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

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

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

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

#[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));
}

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

性能优化版本

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

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]方法，更加简洁高效。

更完整的实现

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

#[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. 网络协议: 验证数据包是否包含特定头部信息

扩展功能

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

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()
}

与其他实现方式的比较

使用标准库方法

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
        }
    }
}

使用自定义迭代器

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