Rust算法-笔记（二）

原创 已于 2025-02-20 17:00:42 修改 · 700 阅读 · 9 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#笔记 #rust #算法 #排序算法

于 2025-02-20 16:53:21 首次发布

一、递归

定义：函数直接或者间接调用自身的一种编程技巧，通过将问题分解为更小的同类子问题来解决；

关键要素：①递归终止的条件，防止无线循环；②递归条件：将问题分解为更小规模的同类问题；

经典递归问题：

①阶乘的计算：计算 n! = n × (n-1) × ... × 1。

pub fn factorial(n: u32) -> u32 {
    if n == 0 {
        1
    } else {
        n * factorial(n - 1)
    }
}

②斐波那契数列：求第 n 项的值，满足 F(n) = F(n-1) + F(n-2)，且 F(0)=0, F(1)=1。

pub fn fibonacci(n: u32) -> u32 {
    if n == 0 {
        0
    } else if n == 1 {
        1
    } else {
        fibonacci(n - 1) + fibonacci(n - 2)
    }
}

二、排序

常见的排序算法：冒泡、插入、选择、快速、归并等

冒泡排序：重复遍历要排序的列表，比较相邻的两个元素，如果顺序错误就交换，直到列表被完全排序；

//generic
fn generic_bubble_sort<T: PartialOrd>(arr: &mut [T]) {
    let len = arr.len();
    for i in 0..len {
        let mut swapped = false;
        for j in 0..(len - i - 1) {
            if arr[j] > arr[j + 1] {
                arr.swap(j, j + 1);
                swapped = true;
            }
        }
        if !swapped {
            break;
        }
    }
}

fn main() {
    let mut numbers = [64, 34, 25, 12, 22, 11, 90];
    generic_bubble_sort(&mut numbers);
    println!("Ordered numbers: {:?}", numbers);

    let mut words = ["banana", "apple", "cherry", "date"];
    generic_bubble_sort(&mut words);
    println!("Ordered words: {:?}", words);
}

插入排序：

将需要排序的一个数组，分为已经排序和未排序的两个区间，初始排序开始，已经排序只有一个元素，然后从未排序的区间取出一个元素放到已经排序的区间里面合适位置放下，直到未排序区间为空为止；

// 为泛型类型 T 实现插入排序，要求 T 可比较且可拷贝（适用于基本数据类型）
fn insertion_sort<T: PartialOrd + Copy>(arr: &mut [T]) {
    // 从第二个元素开始遍历（索引 1）
    for i in 1..arr.len() {
        let key = arr[i]; // 当前待插入元素
        let mut j = i;    // 从右向左查找插入位置

        // 将比 key 大的元素向右移动
        while j > 0 && arr[j - 1] > key {
            arr[j] = arr[j - 1];
            j -= 1;
        }
        arr[j] = key; // 插入 key 到正确位置
    }
}

// 测试代码
#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_empty() {
        let mut arr: Vec<i32> = vec![];
        insertion_sort(&mut arr);
        assert_eq!(arr, vec![]);
    }

    #[test]
    fn test_single_element() {
        let mut arr = vec![5];
        insertion_sort(&mut arr);
        assert_eq!(arr, vec![5]);
    }

    #[test]
    fn test_sorted() {
        let mut arr = vec![1, 2, 3, 4, 5];
        insertion_sort(&mut arr);
        assert_eq!(arr, vec![1, 2, 3, 4, 5]);
    }

    #[test]
    fn test_reverse_sorted() {
        let mut arr = vec![5, 4, 3, 2, 1];
        insertion_sort(&mut arr);
        assert_eq!(arr, vec![1, 2, 3, 4, 5]);
    }

    #[test]
    fn test_random() {
        let mut arr = vec![3, 1, 4, 1, 5, 9, 2, 6];
        insertion_sort(&mut arr);
        assert_eq!(arr, vec![1, 1, 2, 3, 4, 5, 6, 9]);
    }
}

// 示例用法
fn main() {
    let mut numbers = vec![3, 7, 1, 4, 2, 5];
    println!("排序前: {:?}", numbers); // 排序前: [3, 7, 1, 4, 2, 5]
    
    insertion_sort(&mut numbers);
    
    println!("排序后: {:?}", numbers); // 排序后: [1, 2, 3, 4, 5, 7]
}

选择排序：

选择排序的思路和插入排序差不多，但是选在排序是从未排序区间取最小值出来放到已经排序区间的合适位置即可；

// 泛型选择排序实现 (T 需要满足可比较特性)
fn selection_sort<T: PartialOrd>(arr: &mut [T]) {
    let len = arr.len();
    
    // 遍历所有元素（最后一个元素无需处理）
    for i in 0..len {
        // 假设当前索引是最小值的位置
        let mut min_index = i;
        
        // 在剩余元素中查找实际最小值
        for j in (i + 1)..len {
            if arr[j] < arr[min_index] {
                min_index = j;
            }
        }
        
        // 将最小值交换到正确位置
        arr.swap(i, min_index);
    }
}

// 测试模块
#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_empty() {
        let mut arr: Vec<i32> = vec![];
        selection_sort(&mut arr);
        assert_eq!(arr, vec![]);
    }

    #[test]
    fn test_single_element() {
        let mut arr = vec![5];
        selection_sort(&mut arr);
        assert_eq!(arr, vec![5]);
    }

    #[test]
    fn test_sorted() {
        let mut arr = vec![1, 2, 3, 4, 5];
        selection_sort(&mut arr);
        assert_eq!(arr, vec![1, 2, 3, 4, 5]);
    }

    #[test]
    fn test_reverse_sorted() {
        let mut arr = vec![5, 4, 3, 2, 1];
        selection_sort(&mut arr);
        assert_eq!(arr, vec![1, 2, 3, 4, 5]);
    }

    #[test]
    fn test_random() {
        let mut arr = vec![3, 1, 4, 1, 5, 9, 2, 6];
        selection_sort(&mut arr);
        assert_eq!(arr, vec![1, 1, 2, 3, 4, 5, 6, 9]);
    }
}

// 示例用法
fn main() {
    // 测试整数排序
    let mut numbers = vec![3, 7, 1, 4, 2, 5];
    println!("排序前: {:?}", numbers); // 排序前: [3, 7, 1, 4, 2, 5]
    selection_sort(&mut numbers);
    println!("排序后: {:?}", numbers); // 排序后: [1, 2, 3, 4, 5, 7]

    // 测试浮点数排序
    let mut floats = vec![3.2, 1.8, 4.5, 1.1, 5.0];
    selection_sort(&mut floats);
    println!("排序后 floats: {:?}", floats); // [1.1, 1.8, 3.2, 4.5, 5.0]

    // 测试字符串排序
    let mut words = vec!["banana", "apple", "cherry", "date"];
    selection_sort(&mut words);
    println!("排序后 words: {:?}", words); // ["apple", "banana", "cherry", "date"]
}

归并排序：

思路：将需要排序的数组从中间分为两部分，分别将两个部分进行排序之后合并在一起；

// 归并排序实现（泛型版本，支持所有可比较类型）
fn merge_sort<T: Ord + Clone>(arr: &mut [T]) {
    let len = arr.len();
    if len <= 1 {
        return; // 基线条件：空数组或单元素数组直接返回
    }

    // 分割数组为左右两部分
    let mid = len / 2;
    let mut left = arr[..mid].to_vec(); // 使用 to_vec 创建拷贝
    let mut right = arr[mid..].to_vec();

    // 递归排序左右子数组
    merge_sort(&mut left);
    merge_sort(&mut right);

    // 合并排序后的子数组
    merge(arr, &left, &right);
}

// 合并两个有序数组
fn merge<T: Ord + Clone>(arr: &mut [T], left: &[T], right: &[T]) {
    let (mut i, mut j, mut k) = (0, 0, 0);
    let (left_len, right_len) = (left.len(), right.len());

    // 比较左右数组元素并按顺序合并
    while i < left_len && j < right_len {
        if left[i] <= right[j] {
            arr[k] = left[i].clone();
            i += 1;
        } else {
            arr[k] = right[j].clone();
            j += 1;
        }
        k += 1;
    }

    // 处理剩余元素
    while i < left_len {
        arr[k] = left[i].clone();
        i += 1;
        k += 1;
    }
    while j < right_len {
        arr[k] = right[j].clone();
        j += 1;
        k += 1;
    }
}

// 测试模块
#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_empty() {
        let mut arr: Vec<i32> = vec![];
        merge_sort(&mut arr);
        assert_eq!(arr, vec![]);
    }

    #[test]
    fn test_single_element() {
        let mut arr = vec![5];
        merge_sort(&mut arr);
        assert_eq!(arr, vec![5]);
    }

    #[test]
    fn test_already_sorted() {
        let mut arr = vec![1, 2, 3, 4, 5];
        merge_sort(&mut arr);
        assert_eq!(arr, vec![1, 2, 3, 4, 5]);
    }

    #[test]
    fn test_reverse_sorted() {
        let mut arr = vec![5, 4, 3, 2, 1];
        merge_sort(&mut arr);
        assert_eq!(arr, vec![1, 2, 3, 4, 5]);
    }

    #[test]
    fn test_random() {
        let mut arr = vec![3, 1, 4, 1, 5, 9, 2, 6];
        merge_sort(&mut arr);
        assert_eq!(arr, vec![1, 1, 2, 3, 4, 5, 6, 9]);
    }
}

// 示例用法
fn main() {
    // 测试整数排序
    let mut numbers = vec![3, 7, 1, 4, 2, 5];
    println!("排序前: {:?}", numbers); // 排序前: [3, 7, 1, 4, 2, 5]
    merge_sort(&mut numbers);
    println!("排序后: {:?}", numbers); // 排序后: [1, 2, 3, 4, 5, 7]

    // 测试字符串排序
    let mut words = vec!["banana", "apple", "cherry", "date"];
    merge_sort(&mut words);
    println!("排序后 words: {:?}", words); // ["apple", "banana", "cherry", "date"]
}

快速排序：

对于需要排序的数组从中选取一个节点为z节点，遍历数组，和z节点进行比较，将z节点放到中间，大于z节点放在右边，小于z节点放在左边，最后再进行递归排序即可；

// 快速排序实现（泛型版本，支持所有可比较类型）
fn quick_sort<T: Ord>(arr: &mut [T]) {
    if arr.len() <= 1 {
        return; // 基线条件：空数组或单元素数组直接返回
    }
    
    // 选择基准并分区
    let pivot_index = partition(arr);
    
    // 递归排序左右子数组
    let (left, right) = arr.split_at_mut(pivot_index);
    quick_sort(left);
    quick_sort(&mut right[1..]); // 跳过基准元素
}

// 分区函数（Lomuto 分区方案）
fn partition<T: Ord>(arr: &mut [T]) -> usize {
    // 选择中间元素作为基准（避免最坏情况）
    let pivot_index = arr.len() / 2;
    arr.swap(pivot_index, arr.len() - 1); // 移动基准到末尾
    
    let mut i = 0;
    for j in 0..arr.len() - 1 {
        if arr[j] <= arr[arr.len() - 1] {
            arr.swap(i, j);
            i += 1;
        }
    }
    
    // 将基准元素放到正确位置
    arr.swap(i, arr.len() - 1);
    i
}

// 测试模块
#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_empty() {
        let mut arr: Vec<i32> = vec![];
        quick_sort(&mut arr);
        assert_eq!(arr, vec![]);
    }

    #[test]
    fn test_single_element() {
        let mut arr = vec![5];
        quick_sort(&mut arr);
        assert_eq!(arr, vec![5]);
    }

    #[test]
    fn test_already_sorted() {
        let mut arr = vec![1, 2, 3, 4, 5];
        quick_sort(&mut arr);
        assert_eq!(arr, vec![1, 2, 3, 4, 5]);
    }

    #[test]
    fn test_reverse_sorted() {
        let mut arr = vec![5, 4, 3, 2, 1];
        quick_sort(&mut arr);
        assert_eq!(arr, vec![1, 2, 3, 4, 5]);
    }

    #[test]
    fn test_random() {
        let mut arr = vec![3, 1, 4, 1, 5, 9, 2, 6];
        quick_sort(&mut arr);
        assert_eq!(arr, vec![1, 1, 2, 3, 4, 5, 6, 9]);
    }

    #[test]
    fn test_duplicates() {
        let mut arr = vec![5, 3, 5, 3, 5];
        quick_sort(&mut arr);
        assert_eq!(arr, vec![3, 3, 5, 5, 5]);
    }
}

// 示例用法
fn main() {
    // 测试整数排序
    let mut numbers = vec![3, 7, 1, 4, 2, 5];
    println!("排序前: {:?}", numbers); // 排序前: [3, 7, 1, 4, 2, 5]
    quick_sort(&mut numbers);
    println!("排序后: {:?}", numbers); // 排序后: [1, 2, 3, 4, 5, 7]

    // 测试字符串排序
    let mut words = vec!["banana", "apple", "cherry", "date"];
    quick_sort(&mut words);
    println!("排序后 words: {:?}", words); // ["apple", "banana", "cherry", "date"]
}

rust笔记5-derive属性2
shanzhizi的专栏
02-19 967
在 Rust 中，derive 是一种自动为结构体或枚举实现特定 trait 的机制。通过 #[derive(...)] 属性，Rust 编译器可以自动生成一些常见 trait 的实现代码，从而减少手动编写重复代码的工作量。 以下是对 Copy、Clone、Hash 和 Default 这几个常用 trait 的详细介绍和示例
个人学习笔记记录与分享平台-涵盖Android开发-LeetCode算法题解-React框架-Vue框架-Go语言-Java编程-Python编程-Scala语言-Rust语言-大.zip
09-09
Rust语言作为一种系统编程语言，其安全性和并发性能让其成为了性能敏感型应用的首选，平台上关于Rust的学习笔记，引导用户深入理解其内存安全保证和高效性能。 附赠资源文档、说明文件和docsify-notes-master等子...
LeetCode 解题解决方案 —— 使用 Rust 实现
gitblog_00235的博客
08-13 832
LeetCode 解题解决方案 —— 使用 Rust 实现 1. 项目介绍 该项目是用户 aylei 在 GitHub 上创建的一个仓库，名为 leetcode-rust，它包含了用 Rust 语言编写的 LeetCode 题目的解题方案。这个仓库的目的在于提供一个学习和实践 Rust 语言的平台，通过解决数据结构和算法问题来提升编程技能。代码中对于大部分难题，还附带有中文思路注释。 2. 项目快...
Rust实现算法项目
RGBMarco的博客
05-28 1851
这里会用Rust实现一些算法 详情请关注 https://github.com/MarcoEpsilon/Rust-Algorithm
Rust算法-笔记
Mannxix的博客
02-17 337
rust算法笔记
rust笔记2-特质trait
shanzhizi的专栏
02-18 1453
Trait是Rust中实现多态（polymorphism）的核心机制之一。它的设计灵感来自于Haskell的类型类（Type Class）和C++的概念（Concepts）。Trait允许你定义一组方法签名，这些方法可以被不同的类型实现，从而使得不同类型的对象可以共享相同的行为。 Trait的主要目的是提供一种抽象机制，使得代码可以更加通用和可复用。通过Trait，Rust实现了接口继承和代码复用，而不需要传统的类继承机制。
数据结构与算法-Rust 版读书笔记-1语言入门
碳学长的博客
12-10 1307
Rust中并不存在内置库函数，一切都需要自己定义。但是Rust实现了一套高效的宏，包括声明宏、过程宏，利用宏能完成非常多的任务。比如，使用derive宏可以为结构体添加新的功能，常用的println!、vec!、panic!等也是宏。Rust中的宏有两大类：一类是使用macro_rules!声明的声明宏；另一类是过程宏，过程宏又分为三小类——derive宏、类属性宏和类函数宏。声明宏的格式：macro_name!{}。首先是宏名，然后是感叹号，最后是()、[]或{}。
学习笔记 20240801 Rust语言-类型转换
qq_51181223的博客
08-01 854
本节学习会涉及简单的类型转换，也会涉及基于语言底层的运行过程得到的类型分析，最后是前沿但是不安全的Transmute介绍。
数据结构与算法-Rust 版读书笔记-2线性数据结构-队列
碳学长的博客
12-11 299
队列是项的有序集合，其中，添加新项的一端称为队尾，移除项的另一端称为队首。一个元素在从队尾进入队列后，就会一直向队首移动，直到它成为下一个需要移除的元素为止。
学习笔记 20240809 Rust语言-结构体自引用以及解决方法
qq_51181223的博客
08-09 1438
基于Rust语言圣经的学习笔记之结构体自引用以及解决方法
精选资源
Rust项目-基于rust和区块链技术的后端记账项目代码
03-12
core 文件夹在Rust项目中可能包含了核心逻辑或基础模块，对于区块链项目而言，这个文件夹可能封装了区块链的核心算法，如共识机制、区块生成和验证、状态数据库等。 这个Rust项目是一个旨在利用Rust语言的高效和...
运放学习笔记
Z97371539的博客
12-13 562
单电源运放是指仅使用单一电源电压（例如，+5V）和地（0V）作为电源供给的运放。也就是说，它只需要一个正电压和地作为参考电压，而不需要负电压。
pcie笔记
bortonyu的博客
12-11 776
模式全称描述共用参考时钟Root Complex（RC）和 Endpoint（EP）使用同一颗外部 RefclkSRNSRC 和 EP 使用独立时钟源，但 不允许展频（SSC）SRISRC 和 EP 使用独立时钟源，允许各自带有 SSC 抖动txt复制编辑FS 表示信号的总摆幅，用于判断是否满足发送器输出的最大电压范围（如 800mV full swing）。Full Swing 模式下：FS ∈ [24, 63]Reduced Swing 模式下：FS ∈ [12, 63]
先立后破：Linux 下“新建管理员 → 验证 → 禁用 root 远程 SSH”的零翻车笔记
weixin_45626288的博客
12-12 529
本文提供了一套零风险的Linux服务器安全加固流程，重点解决等保2.0要求的"禁用root远程SSH"需求。通过"先立后破"原则，先创建并验证新管理员账号的sudo权限，再禁用root远程登录，全程保持root会话不断开作为应急通道。关键步骤包括：创建新管理员账号、配置sudo权限、严格测试新账号功能、安全修改sshd配置、保留本地root登录权限等。文章特别强调验证环节的重要性，并提供了快速回滚方案，确保运维人员不会因配置失误导致服务器失联。这套方法适用于Kylin
AD学习笔记-36 gerber文件输出
2401_83451707的博客
12-14 292
今天，我们学习如何导出gerber文件，这是我们给板厂的最终文件。
Android学Dart学习笔记第十四节 库和导库
weixin_44656996的博客
12-15 694
其他语言中的访问修饰符关键字提供了更细粒度的控制，而Dart使用下划线和基于库的隐私提供了直接的配置机制，有助于高效实现动态访问，并改进了树抖动（死代码消除）。库不仅提供api，还是隐私的单位：以下划线（_）开头的标识符只在库内部可见。当你导入的多个库中，使用了相同的类名时，可以为库起个别名，使用 别名.类名 明确指定所引用的类。使用import来指定如何在另一个库的作用域中使用来自一个库的命名空间。带有通配符_的导入前缀是不绑定的，但可以访问该库中的非私有扩展。
Compose笔记(六十)--TriStateCheckbox
ljt2724960661的博客
12-14 149
 这一节主要了解一下Compose中的TriStateCheckbox,TriStateCheckbox是Jetpack Compose中支持三种状态的复选框组件，相比...
C++基础笔记（二）队列deque,queue和堆priority_queue
qq_43869689的博客
12-12 317
由于deque不完全连续的实现思想，在插入/删除时，如果涉及到新块扩容（增加一个新的block）有可能导致迭代器失效，建议稳妥的做法时涉及到频繁的删除就用list链表，别用的队列实现，或者分两边操作，第一遍只遍历检查，确定要删除的数据，第二遍开始从后往前删除（一般情况不建议删除，加个标记表示这个数据失效就行，比如用一个set或者数组记录哪些元素失效）。关于priority_queue也是差不多。
【大模型】happy-llm笔记
最新发布
weixin_45207619的博客
12-16 117
今天看了这套课程的第二章到第四章的内容，对自己一直以来好奇的一些llm相关的问题有了解答。将我遇到的问题整理到下面，部分可能没有回答，感兴趣的同学可以去原课程查找。happy-llm是datawhale发布的一套关于llm的教程，链接。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值