素数筛算法
1.1 试除法
#include <iostream>
using namespace std;
// 判断一个数是否为素数的函数
bool isPrime(int n) {
if (n <= 1) return false; // 小于等于1的数都不是素数
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) { // 如果n能被i整除,说明n不是素数
return false;
}
}
return true; // 如果没有发现因子,n是素数
}
int main() {
int n;
cout << "请输入一个整数: ";
cin >> n;
if (isPrime(n)) {
cout << n << " 是素数。" << endl;
} else {
cout << n << " 不是素数。" << endl;
}
return 0;
}
1.2 埃筛
#include <iostream>
#include <vector>
using namespace std;
// 使用埃拉托色尼筛法生成所有小于等于n的素数
vector<int> sieveOfEratosthenes(int n) {
vector<bool> isPrime(n + 1, true); // 初始化一个布尔数组,将所有元素标记为true
isPrime[0] = isPrime[1] = false; // 0和1不是素数,标记为false
for (int i = 2; i * i <= n; i++) {
if (isPrime[i]) {
// 将i的所有倍数标记为false
for (int j = i * i; j <= n; j += i) {
isPrime[j] = false;
}
}
}
// 收集所有标记为true的素数
vector<int> primes;
for (int i = 2; i <= n; i++) {
if (isPrime[i]) {
primes.push_back(i);
}
}
return primes;
}
int main() {
int n;
cout << "请输入一个整数n,生成所有小于等于n的素数: ";
cin >> n;
vector<int> primes = sieveOfEratosthenes(n);
cout << "小于等于 " << n << " 的素数有: ";
for (int prime : primes) {
cout << prime << " ";
}
cout << endl;
return 0;
}
代码解释如下:
首先,初始化一个布尔数组,假定所有数都为素数。数组的大小为 n + 1
,初始值为 true
。我们将 0
和 1
设为 false
,因为它们不是素数。
接着,从 2
开始遍历,如果 i
是素数(isPrime[i]
为 true
),则将 i
的所有倍数标记为合数。内层循环从 i * i
开始,因为小于 i * i
的倍数已经被之前的素数筛选掉了。
然后,我们遍历布尔数组,将所有标记为 true
的数收集到素数列表中。
最后,通过 sieveOfEratosthenes
函数生成素数列表,并输出这些素数。例如,输入 n = 30
,输出 小于等于 30 的素数有: 2 3 5 7 11 13 17 19 23 29
。
埃拉托色尼筛法的时间复杂度为 O(n log log n)
,在计算素数时非常高效。
1.3 线性筛
线性筛法是一种改进的素数筛选算法,它的时间复杂度为 (O(n))。与埃拉托色尼筛法相比,线性筛法不会重复标记同一个数,从而使筛选过程更加高效。
下面是线性筛法的C++代码示例,用于生成某个范围内的所有素数:
#include <iostream>
#include <vector>
using namespace std;
// 使用线性筛法生成所有小于等于n的素数
vector<int> linearSieve(int n) {
vector<int> primes; // 存储所有的素数
vector<bool> isPrime(n + 1, true); // 标记素数的布尔数组
for (int i = 2; i <= n; i++) {
if (isPrime[i]) {
primes.push_back(i); // i 是素数,将其加入素数列表
}
for (int j = 0; j < primes.size() && i * primes[j] <= n; j++) {
isPrime[i * primes[j]] = false; // 标记 i * primes[j] 为合数
if (i % primes[j] == 0) {
break; // 如果 i 是 primes[j] 的倍数,停止进一步的标记
}
}
}
return primes;
}
int main() {
int n;
cout << "请输入一个整数n,生成所有小于等于n的素数: ";
cin >> n;
vector<int> primes = linearSieve(n);
cout << "小于等于 " << n << " 的素数有: ";
for (int prime : primes) {
cout << prime << " ";
}
cout << endl;
return 0;
}
代码解释如下:
首先,初始化一个布尔数组 isPrime
,用于标记哪些数是素数。初始化时,所有数都假定为素数(标记为 true
)。同时,准备一个整数向量 primes
来存储所有找到的素数。
然后,我们从 2
开始遍历每个整数 i
。如果 i
是素数(即 isPrime[i]
为 true
),将 i
加入到 primes
列表中。
对于每个 i
,我们使用当前的素数列表 primes
,标记 i
与每个素数 primes[j]
的乘积为合数。如果 i
是 primes[j]
的倍数(即 i % primes[j] == 0
),那么我们可以停止标记,因为 i * primes[j]
是 primes[j]
的倍数,将来会由其他较小的素数标记。
最后,函数返回所有找到的素数,并在 main
函数中输出这些素数。
例如,输入 n = 30
,输出 小于等于 30 的素数有: 2 3 5 7 11 13 17 19 23 29
。
线性筛法在处理大范围的素数时非常高效,因为它只标记每个合数一次,时间复杂度为 (O(n))。