Question

我一直在尝试使用以下代码实现筛选算法：

#include <iostream>
#include <vector>

using namespace std;

int main() {
    vector <int> primes; //all the primes found
    int theLimit = 10E5;

    void sieve (vector <int> &primes, int theLimit); //declaring the function
    sieve (primes, theLimit);

    return 0;
}

void sieve (vector <int> &primes, int theLimit) {
    const int SIZE = theLimit + 1;
    bool oddNonPrimes[SIZE]; //the array that tells you that tells you if the number that represents the current index is a non-prime or not

    for (int i = 0; i < theLimit; ++i) //setting all the array indicies to false
        oddNonPrimes[i] = false;

    primes.push_back(2);

    for (int i = 3; i < theLimit; i += 2){ //start searching for primes,we start with the number 3 and check all odd numbers only
        if (!oddNonPrimes[i]){
             int currNum = i;
             primes.push_back(currNum);
             for (int factor = 2; currNum <= theLimit; ++factor){
                currNum *= factor;
                oddNonPrimes[currNum] = true;
                currNum = i;
            }
        }
    }

}

我已经尝试降低尺寸，以确保我没有使用太多内存，但它仍然无法正常工作。我也尝试过寻找答案，但我没有找到任何答案。

可能导致Seg故障的原因是什么？为什么？

Answer 1

首先，我想说的是，为了搜索所有素数而运行的for循环应该通过查看if（！oddNonPrimes [i]）是否为真而应该仅针对sqrt（ theLimit）因为它会降低复杂性。以下是我希望您参考的筛选方法。

#include<bits/stdc++.h>
using namespace std;

bool *primality=new bool[10000010];
long long int *p = new long long int[1000001];
int main(){
    long long count=0;
    for(long long int i=0; i<10000010; i++)
        primality[i]=true;
    for(int i=2; i<10010; i++)
        if(primality[i])
            for(long long j=i*i; j<10000010; j+=i)
                primality[j]=false;
            for(int i=2; i<10000010; i++)
               if(primality[i]){
                   p[count]=i;
                   count++;
               }
 }

这是从我的一个代码中获取的。我认为这会对你有所帮助。：）

Answer 2

首先，抱歉浪费你的时间。

我应该使用：

for (int factor = 2; (currNum * factor) <= theLimit; ++factor)

而不是：

for (int factor = 2; currNum <= theLimit; ++factor)

否则当currNum很大然后乘以因子时，它可能会变得大于限制，因此它会尝试访问超出数组大小的索引。

使用筛分算法进行分段故障（核心转储）

2 个答案: