三种素数筛

定义

素数筛顾名思义就是给定一个区间范围，找出其中的素数。

一、直接筛法

我们直观上想到的就是试错法，简单容易，我们直接去找它是否有其他不是1和本身的因子，如果没有那么就是素数，如果有那就是合数。

首先从[2,n-1]这个区间对每个数来判断是否是素数，但是我们可以来对[2，n-1]，这个区间里面的所有数来分析一下。

根据基础知识我们可以知道，数分奇数和偶数，对于偶数来说我们都知道，偶数可以被2整除，所以[2,n-1]这个区间里面除2以外的所有偶数都不是素数。

 因此如果我们把这个区间里面的偶数都去除掉的话，那么我们这里就少了一半的数据要去通过内层的循环，所以减少了数据的处理，时间复杂度也会有下降。

 数字的因子具有一个显著特性，即它们以成对的形式出现（两个成对的因子相乘得到原数字），并且成对出现的因子分布在sqrt(n)的两侧。

        简单证明一下为什么一定分布在sqrt(n)两侧：假设k=sqrt(n)，那么k*k=n

        如果成对的两个因子不分布在k的两侧，比如同时大于k或者同时小于k。因为k*k=n，那么这两个成对因子相乘的结果要么是大于n，要么是小于n。既然相乘结果都不是n，那么就不是n的因子，则与最开始的假设相悖。

代码：

#include <math.h>
#include<stdio.h>
int main()
{
    int N;
    int flag = 0;
    scanf("%d",&N);
    if(N >= 2){
    printf("2\n");
    for(int i = 3;i <= N;i += 2){
        for(int j = 3;j < sqrt(i) ;j += 2){    //把i/2换成sqrt(i)
            if(i % j == 0){
                flag = 1;
            }
        }
        if(flag == 0){
            printf("%d\n",i);
        }
        flag = 0;
        }
    }
    return 0;
}

二、埃氏筛

埃氏筛（Sieve of Eratosthenes）是一种用来找出一定范围内所有质数的经典算法。其基本思想是从小到大逐个筛选掉合数，最终剩下的就是质数。

代码：

#include <iostream>
#include <vector>

using namespace std;

vector<int> sieve(int n) {
    vector<bool> isPrime(n + 1, true); // 初始化一个大小为 n+1 的布尔数组，初始值全部为 true
    vector<int> primes; // 存放找到的质数

    for (int p = 2; p <= n; ++p) {
        if (isPrime[p]) {
            primes.push_back(p); // 将当前的 p 加入到质数列表中

            // 筛掉 p 的倍数
            for (int i = p * p; i <= n; i += p) {
                isPrime[i] = false;
            }
        }
    }

    return primes;
}

int main() {
    int n;
    cout << "Enter a number (n): ";
    cin >> n;

    vector<int> primes = sieve(n);

    cout << "Prime numbers up to " << n << " are:\n";
    for (int prime : primes) {
        cout << prime << " ";
    }
    cout << endl;

    return 0;
}

1. 数据结构：

   • vector<bool> isPrime(n + 1, true);：使用一个布尔型 vector，大小为 n+1，用来标记每个数字是否为质数。初始时所有元素都标记为 true，表示都是质数的候选。

2. 算法流程：

   • 外层循环 for (int p = 2; p <= n; ++p) 遍历从 2 到 n 的每个数。
   • 如果 isPrime[p] 为 true，则将 p 加入质数列表 primes 中，因为 p 是质数。
   • 然后，从 p 的平方开始，逐步标记其倍数为 false，表示这些倍数不是质数。
   • 内层循环 for (int i = p * p; i <= n; i += p)，从 p 的平方开始，每次增加 p，标记 isPrime[i] = false;。

埃氏筛法是一种高效的算法，时间复杂度为(n*log(logn))，适用于找出较小范围内的所有质数。

三、欧拉筛（线性筛）

欧拉筛是一种优化过的质数筛法，相比于传统的埃氏筛法，在找出一定范围内所有质数时效率更高。它的基本思想是利用了每个合数只被其最小质因数筛去一次的性质，从而减少了内循环的次数，提高了效率。

代码：

#include <iostream>
#include <vector>
using namespace std;

vector<int> eulerSieve(int n) {
    vector<bool> isPrime(n + 1, true); // 初始化一个大小为 n+1 的布尔数组，初始值全部为 true
    vector<int> primes; // 存放找到的质数

    for (int p = 2; p <= n; ++p) {
        if (isPrime[p]) {
            primes.push_back(p); // 将当前的 p 加入到质数列表中

            // 使用 p 去筛掉其倍数
            for (int i = p * 2; i <= n; i += p) {
                isPrime[i] = false;
            }
        }
    }

    return primes;
}

int main() {
    int n;
    cout << "Enter a number (n): ";
    cin >> n;

    vector<int> primes = eulerSieve(n);

    cout << "Prime numbers up to " << n << " are:\n";
    for (int prime : primes) {
        cout << prime << " ";
    }
    cout << endl;

    return 0;
}

欧拉筛使用每个质数仅筛掉其倍数一次，而埃氏筛在内层循环中多次筛选每个质数的倍数。

埃氏筛依旧会有重复问题，比如当我们要筛选掉12这个合数时，从2开始倍增到6，也就是2 * 6 = 12，这样就筛选了一次，但是，当我们从3开始倍增到4，也就是3 * 4 = 12，这样就导致对12筛选了两次，但是上面埃氏筛的所有优化都不能排除掉这个问题，所以就需要欧拉筛来解决这个问题。

欧拉筛的时间复杂度为 ( O(n) )，比埃氏筛的 ( O(n \log \log n) ) 更快，尤其在大范围内的质数查找时，效果显著。

因此，欧拉筛是在实际应用中常用的一种高效的质数筛法，适合于需要查找大量质数的情况。