素数筛总结

最新推荐文章于 2023-11-01 21:23:34 发布

wodongx123

最新推荐文章于 2023-11-01 21:23:34 发布

阅读量534

点赞数 1

分类专栏：算法文章标签：算法

本文链接：https://blog.csdn.net/qq_41872247/article/details/103039766

版权

算法专栏收录该内容

5 篇文章 0 订阅

订阅专栏

素数筛

1. 基本解法
2. 普通筛
3. 线性筛
参考材料

1. 基本解法

基本的素数判断条件是，从1和这个数本身以外，中间没有任何数可以被其整除的数就是素数。
反过来也可以说如果有一个数可以被整除就是合数了。
所以基本的素数判断就这么写：

bool isPrime(int n){
    for (int i = 2; i < n; ++i) {
        if (n % i == 0)
            return false;
    }
    return true;
}

然后，求从1到数字n的所有素数就是在外面再套一个for循环，从2开始找就行。

bool isPrime[100000]; //表示某一个数是不是素数
int prime[100000];  //所有素数的排列
int prime_c; // 素数的数量

void getPrime(int n){
    memset(isPrime, true, sizeof(isPrime));  //先把所有的数都设成素数
    prime_c = 0;
    for (int i = 2; i < n; ++i) {

        for (int j = 2; j < i; ++j) {
            if (i % j == 0) {
                isPrime[i] = false;
                break;
            }
        }
        if (isPrime[i])
            prime[prime_c++] = i;
    }
}

由于是两个for循环，所以时间复杂度为o(n^2)。

2. 普通筛

接下来说素数筛，一般也叫做Eratosthenes筛或者埃式筛。

对于刚才的解法o(n^2)而言，所有的数都要从2开始重新整除，这就造成了很多的时间浪费。这里就要用到新的解法。

在求素数的时候，可以很容易的得到一个想法：任何一个数，他的整数倍数都绝对不会是素数。
比如说2的2倍数4，3倍数6，4倍数8等等都不是素数。
那么，在当把所有数的整倍数筛选掉后，剩下的就都是素数了。
具体的解法是这样：从2开始，每遇到一个数，就将它的整数倍数(从2倍数开始直到乘后大于上限)设为合数。

bool isPrime[100000]; //表示某一个数是不是素数
int prime[100000];  //所有素数的排列
int prime_c; // 素数的数量

void eGetPrime(int n){
    memset(isPrime, true, sizeof(isPrime));  //先把所有的数都设成素数
    prime_c = 0;
    for (int i = 2; i < n; i++){
        if (isPrime[i]){
            prime[prime_c++] = i;
        }
        for (int j = 2; i*j < n; ++j) {
            isPrime[i*j] = false;
        }
    }
}

但是你会更明显的发现一个事实，那就是如果一个数已经是合数，那他的倍数就更不可能是素数了，所以再略作修改。

void getPrime(int n){
    memset(isPrime, true, sizeof(isPrime));  //先把所有的数都设成素数
    prime_c = 0;
    for (int i = 2; i < n; i++){
        if (isPrime[i])
            prime[prime_c++] = i;
        else
            continue; //如果是合数，就跳过这次的for循环
        
        for (int j = 2; i*j < n; ++j) {
            isPrime[i*j] = false;
        }
    }
}

这次修改虽然只加了一点，但是又一次的减少了算法的所需时间，最终的时间复杂度为o(nlog2n)。

3. 线性筛

最后说时间复杂度最低的线性筛，Euler筛也称作欧拉筛。

对于埃式筛而言，可以很明显的看到还有一个缺点就是，有些数字还是会做出重复的判断，比如说6同时是2和3的整数倍数，那么他就会两次被打上标记，这个也是耗时变长的一部分原因。

而欧拉筛最终会消除这种重复的判断，让时间复杂度变成o(n)，可以说是不能再快了。

那么到底是怎么做到的，这里用上了用来保存素数的数组prime[]，主要思想是：让每个合数只被它的最小质因子筛选一次，以达到不重复的目的。

质因数（素因数）：任何一个合数都一定有一个最小质因数
质因数就是一个数的约数，并且是质数。
比如8=2×2×2，2就是8的质因数；
12=2×2×3，2和3就是12的质因数。

bool isPrime[100000]; //表示某一个数是不是素数
int prime[100000];  //所有素数的排列
int prime_c; // 素数的数量
void getPrime(int n){
    memset(isPrime, true, sizeof(isPrime));  //先把所有的数都设成素数
    prime_c = 0;
    for (int i = 2; i < n; i++){
        if (isPrime[i])
            prime[prime_c++] = i;

        for (int j = 0; j<prime_c && i*prime[j]<n; ++j) {
            isPrime[i * prime[j]] = false;  //用i * prime[j]来代替 i * j
            if (i % prime[j] == 0) break; //重要
        }
    }
}