当前位置：首页 > news >正文

Rust 练习册：Prime Factors与质因数分解

news 2025/11/9 7:01:54

质因数分解是数论中的一个重要概念，指将一个正整数分解为一系列质数的乘积。在 Exercism 的 “prime-factors” 练习中，我们需要实现一个函数来计算给定数字的质因数分解。这不仅能帮助我们掌握数论算法和数学计算技巧，还能深入学习Rust中的递归算法、迭代器使用和性能优化。

什么是质因数分解？

质因数分解是将一个正整数表示为质数乘积的过程。根据算术基本定理，任何大于1的正整数都可以唯一地表示为质数的乘积。例如：

12 = 2 × 2 × 3
901255 = 5 × 17 × 23 × 461

质因数分解在以下领域有重要应用：

密码学：RSA加密算法的基础
数学计算：求最大公约数、最小公倍数等
算法竞赛：数论相关问题
计算机科学：哈希函数设计等

让我们先看看练习提供的函数实现：

pub fn factors(n: u64) -> Vec<u64> {let mut res = vec![];match (2..n + 1).find(|x| n % x == 0) {Some(x) => {res.push(x);res.append(&mut factors(n / x));}None if n != 1 => {res.push(n);}_ => {}}res
}

这是一个递归实现，通过查找最小因子并递归处理商来完成质因数分解。

设计分析

1. 核心要求

质因数计算：正确计算一个数的所有质因数
因子排序：按升序返回质因数
重复因子：正确处理重复的质因数
边界处理：正确处理特殊数字如1等

2. 技术要点

递归算法：使用递归分解数字
迭代器使用：利用Rust强大的迭代器功能
性能优化：优化算法以处理大数
内存管理：合理管理向量的创建和合并

完整实现

1. 基础递归实现

pub fn factors(n: u64) -> Vec<u64> {let mut res = vec![];match (2..n + 1).find(|x| n % x == 0) {Some(x) => {res.push(x);res.append(&mut factors(n / x));}None if n != 1 => {res.push(n);}_ => {}}res
}

2. 迭代实现

pub fn factors(n: u64) -> Vec<u64> {let mut factors = Vec::new();let mut current = n;let mut candidate = 2;while candidate * candidate <= current {while current % candidate == 0 {factors.push(candidate);current /= candidate;}candidate += 1;}if current > 1 {factors.push(current);}factors
}

3. 优化的迭代实现

pub fn factors(n: u64) -> Vec<u64> {if n <= 1 {return vec![];}let mut factors = Vec::new();let mut current = n;// 处理因子2while current % 2 == 0 {factors.push(2);current /= 2;}// 处理奇数因子，从3开始，只检查到sqrt(current)let mut candidate = 3;while candidate * candidate <= current {while current % candidate == 0 {factors.push(candidate);current /= candidate;}candidate += 2; // 只检查奇数}// 如果current大于1，那么它本身就是一个质因数if current > 1 {factors.push(current);}factors
}

测试用例分析

通过查看测试用例，我们可以更好地理解需求：

#[test]
fn test_no_factors() {assert_eq!(factors(1), vec![]);
}

1没有质因数，应返回空向量。

#[test]
fn test_prime_number() {assert_eq!(factors(2), vec![2]);
}

质数的质因数分解就是它本身。

#[test]
fn test_square_of_a_prime() {assert_eq!(factors(9), vec![3, 3]);
}

质数的平方应返回两个相同的质因数。

#[test]
fn test_cube_of_a_prime() {assert_eq!(factors(8), vec![2, 2, 2]);
}

质数的立方应返回三个相同的质因数。

#[test]
fn test_product_of_primes_and_non_primes() {assert_eq!(factors(12), vec![2, 2, 3]);
}

合数应正确分解为质因数。

#[test]
fn test_product_of_primes() {assert_eq!(factors(901_255), vec![5, 17, 23, 461]);
}

大数也应正确分解。

#[test]
fn test_factors_include_large_prime() {assert_eq!(factors(93_819_012_551), vec![11, 9539, 894_119]);
}

包含大质因数的数也应正确处理。

性能优化版本

考虑性能的优化实现：

pub fn factors(n: u64) -> Vec<u64> {if n <= 1 {return vec![];}let mut factors = Vec::new();let mut current = n;// 特殊处理小数字if current == 2 {return vec![2];}if current == 3 {return vec![3];}// 处理因子2while current & 1 == 0 {  // 使用位运算检查偶数factors.push(2);current >>= 1;  // 使用位运算除以2}// 处理奇数因子let mut candidate = 3;while candidate * candidate <= current {while current % candidate == 0 {factors.push(candidate);current /= candidate;}candidate += 2;}// 如果current大于1，那么它本身就是一个质因数if current > 1 {factors.push(current);}factors
}// 使用预计算质数表的版本
pub fn factors_with_primes(n: u64) -> Vec<u64> {if n <= 1 {return vec![];}let mut factors = Vec::new();let mut current = n;// 预计算的小质数表let small_primes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47];for &prime in &small_primes {if prime * prime > current {break;}while current % prime == 0 {factors.push(prime);current /= prime;}}// 处理剩余的大质数if current > 1 {factors.push(current);}factors
}// 使用6k±1优化的版本
pub fn factors_optimized(n: u64) -> Vec<u64> {if n <= 1 {return vec![];}let mut factors = Vec::new();let mut current = n;// 处理因子2while current & 1 == 0 {factors.push(2);current >>= 1;}// 处理因子3while current % 3 == 0 {factors.push(3);current /= 3;}// 所有其他质数都可以表示为6k±1的形式let mut i = 5;while i * i <= current {while current % i == 0 {factors.push(i);current /= i;}while current % (i + 2) == 0 {factors.push(i + 2);current /= (i + 2);}i += 6;}// 如果current大于1，那么它本身就是一个质因数if current > 1 {factors.push(current);}factors
}

错误处理和边界情况

考虑更多边界情况的实现：

pub fn factors(n: u64) -> Vec<u64> {// 处理边界情况if n <= 1 {return vec![];}let mut factors = Vec::new();let mut current = n;// 处理因子2while current & 1 == 0 {factors.push(2);current >>= 1;}// 处理奇数因子let mut candidate = 3;while candidate * candidate <= current {while current % candidate == 0 {factors.push(candidate);current /= candidate;}candidate += 2;}// 如果current大于1，那么它本身就是一个质因数if current > 1 {factors.push(current);}factors
}// 返回Result的版本
#[derive(Debug, PartialEq)]
pub enum FactorError {InvalidInput,
}impl std::fmt::Display for FactorError {fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {match self {FactorError::InvalidInput => write!(f, "输入无效"),}}
}impl std::error::Error for FactorError {}pub fn factors_safe(n: u64) -> Result<Vec<u64>, FactorError> {if n == 0 {return Err(FactorError::InvalidInput);}Ok(factors(n))
}// 支持更大整数类型的版本
pub fn factors_u128(n: u128) -> Vec<u128> {if n <= 1 {return vec![];}let mut factors = Vec::new();let mut current = n;// 处理因子2while current & 1 == 0 {factors.push(2);current >>= 1;}// 处理奇数因子let mut candidate = 3;while candidate * candidate <= current {while current % candidate == 0 {factors.push(candidate);current /= candidate;}candidate += 2;}// 如果current大于1，那么它本身就是一个质因数if current > 1 {factors.push(current);}factors
}

扩展功能

基于基础实现，我们可以添加更多功能：

pub struct PrimeFactorizer;impl PrimeFactorizer {pub fn new() -> Self {PrimeFactorizer}pub fn factors(&self, n: u64) -> Vec<u64> {factorize(n)}// 获取质因数及其指数pub fn factorize_with_powers(&self, n: u64) -> Vec<(u64, u32)> {if n <= 1 {return vec![];}let factors = self.factors(n);let mut result = Vec::new();if !factors.is_empty() {let mut current_factor = factors[0];let mut count = 1;for &factor in &factors[1..] {if factor == current_factor {count += 1;} else {result.push((current_factor, count));current_factor = factor;count = 1;}}// 不要忘记最后一个因子result.push((current_factor, count));}result}// 判断是否为质数pub fn is_prime(&self, n: u64) -> bool {if n <= 1 {return false;}if n <= 3 {return true;}if n % 2 == 0 || n % 3 == 0 {return false;}let factors = self.factors(n);factors.len() == 1 && factors[0] == n}// 计算所有因数（不仅仅是质因数）pub fn all_divisors(&self, n: u64) -> Vec<u64> {if n == 0 {return vec![];}let factor_powers = self.factorize_with_powers(n);let mut divisors = vec![1];for (prime, power) in factor_powers {let mut new_divisors = Vec::new();let mut multiplier = 1;for _ in 0..=power {for &divisor in &divisors {new_divisors.push(divisor * multiplier);}multiplier *= prime;}divisors = new_divisors;}divisors.sort_unstable();divisors}// 计算因数个数pub fn divisor_count(&self, n: u64) -> u64 {if n <= 1 {return n; // 1的因数个数是1，0的因数个数是0}let factor_powers = self.factorize_with_powers(n);factor_powers.iter().map(|&(_, power)| power as u64 + 1).product()}// 计算因数之和pub fn divisor_sum(&self, n: u64) -> u64 {if n <= 1 {return n;}let factor_powers = self.factorize_with_powers(n);factor_powers.iter().map(|&(prime, power)| {let prime_pow = prime.pow(power + 1);(prime_pow - 1) / (prime - 1)}).product()}
}fn factorize(n: u64) -> Vec<u64> {if n <= 1 {return vec![];}let mut factors = Vec::new();let mut current = n;// 处理因子2while current & 1 == 0 {factors.push(2);current >>= 1;}// 处理奇数因子let mut candidate = 3;while candidate * candidate <= current {while current % candidate == 0 {factors.push(candidate);current /= candidate;}candidate += 2;}// 如果current大于1，那么它本身就是一个质因数if current > 1 {factors.push(current);}factors
}// 质因数分解结果分析
pub struct FactorizationAnalysis {pub number: u64,pub prime_factors: Vec<u64>,pub factor_powers: Vec<(u64, u32)>,pub is_prime: bool,pub divisor_count: u64,pub divisor_sum: u64,
}impl PrimeFactorizer {pub fn analyze(&self, n: u64) -> FactorizationAnalysis {let prime_factors = self.factors(n);let factor_powers = self.factorize_with_powers(n);let is_prime = self.is_prime(n);let divisor_count = self.divisor_count(n);let divisor_sum = self.divisor_sum(n);FactorizationAnalysis {number: n,prime_factors,factor_powers,is_prime,divisor_count,divisor_sum,}}
}// 便利函数
pub fn factors(n: u64) -> Vec<u64> {let factorizer = PrimeFactorizer::new();factorizer.factors(n)
}pub fn is_prime(n: u64) -> bool {let factorizer = PrimeFactorizer::new();factorizer.is_prime(n)
}pub fn format_factorization(n: u64) -> String {let factorizer = PrimeFactorizer::new();let factor_powers = factorizer.factorize_with_powers(n);if factor_powers.is_empty() {return "1".to_string();}let parts: Vec<String> = factor_powers.iter().map(|&(prime, power)| {if power == 1 {prime.to_string()} else {format!("{}^{}", prime, power)}}).collect();parts.join(" × ")
}

实际应用场景

质因数分解在实际开发中有以下应用：

密码学：RSA加密算法的基础运算
数学软件：计算器和数学分析工具
算法竞赛：数论相关问题的解决
教育工具：数学教学演示
游戏开发：数学益智游戏
数据分析：数字模式识别
性能测试：计算密集型算法基准测试
科学计算：数论研究工具

算法复杂度分析

时间复杂度：O(√n)
- 其中n是输入数字，只需要检查到√n的因子
空间复杂度：O(log n)
- 需要存储质因数，最坏情况下为log n个因子

与其他实现方式的比较

// 使用递归的实现
pub fn factors_recursive(n: u64) -> Vec<u64> {fn factorize_recursive(num: u64, candidate: u64) -> Vec<u64> {if candidate * candidate > num {if num > 1 {return vec![num];}return vec![];}if num % candidate == 0 {let mut result = vec![candidate];result.append(&mut factorize_recursive(num / candidate, candidate));result} else {factorize_recursive(num, candidate + 1)}}if n <= 1 {vec![]} else {factorize_recursive(n, 2)}
}// 使用迭代器的函数式实现
pub fn factors_functional(n: u64) -> Vec<u64> {if n <= 1 {return vec![];}let mut factors = Vec::new();let mut current = n;// 处理2while current % 2 == 0 {factors.push(2);current /= 2;}// 处理奇数因子factors.extend((3..).step_by(2).take_while(|&i| i * i <= current).filter(|&i| {while current % i == 0 {factors.push(i);current /= i;}current > 1}).collect::<Vec<u64>>());if current > 1 {factors.push(current);}factors
}// 使用第三方库的实现
// [dependencies]
// primal = "0.3"pub fn factors_with_primal(n: u64) -> Vec<u64> {// 使用primal库进行质数相关计算// 这里只是一个示例，实际实现会更复杂unimplemented!()
}// 并行实现
use rayon::prelude::*;pub fn factors_parallel(n: u64) -> Vec<u64> {// 对于质因数分解，并行化并不总是有益的// 因为这是一个串行依赖的过程// 但我们可以并行处理多个数字的分解unimplemented!()
}// 使用状态机的实现
#[derive(Debug, Clone)]
enum FactorizationState {Start,Processing { current: u64, candidate: u64 },Done { factors: Vec<u64> },
}pub fn factors_state_machine(n: u64) -> Vec<u64> {let mut state = FactorizationState::Start;loop {match state {FactorizationState::Start => {if n <= 1 {state = FactorizationState::Done { factors: vec![] };} else {state = FactorizationState::Processing { current: n, candidate: 2 };}}FactorizationState::Processing { current, candidate } => {if candidate * candidate > current {if current > 1 {state = FactorizationState::Done { factors: vec![current] };} else {state = FactorizationState::Done { factors: vec![] };}} else if current % candidate == 0 {// 这里需要更复杂的逻辑来处理状态转换unimplemented!()} else {state = FactorizationState::Processing { current, candidate: candidate + 1 };}}FactorizationState::Done { factors } => {return factors;}}}
}