#C语言#关于求素数的思路(一般筛法到线性筛)

Target:输入一个正整数n，输出1~n的所有素数

让我们再来回顾一下求素数的算法，关于素数的算法是信息学竞赛和程序设计竞赛中常考的数论知识，希望通过此次对算法思路的整理能对大家有所帮助。

1.首先是判断一个数是不是素数的最原始的方案：O(n*n)

   

#include<stdio.h>
#include<stdbool.h>
#include<math.h>
bool judge(int n)
{
    int i;
    for(i=2;i<n;i++)
        if(n%i==0)
        {
            return false;
            break;
        }
    return true;
}

聪明一点的同学可能会想到给n开平方来降低时间复杂度至O(n*sqrt(n))即：

#include<stdio.h>
#include<stdbool.h>
#include<math.h>
bool judge(int n)
{
    int i;
    for(i=2;i<=sqrt(n);i++)
        if(n%i==0)
        {
            return false;
            break;
        }
    return true;
}

这里给不懂的同学提示一下原理：

简单解释一下:因数都是成对出现的。比如，100的因数有：1和100、2和50、4和25、5和20、10和10。即成对的因数，其中一个必然小于等于100的开平方，另一个大于等于100的开平方。因此只要判断2~sqrt(n)的因数即可。

2.筛法的引入

    有了以上思路，可以简单粗暴地对1~n内的每个数都判断一次，然后把所有的素数输出。但当n特别大时，这样的算法显然效率太低，于是在这里提供筛法的思想：我们可以构建一个大小为n+1的bool类型数组，并将各元素初始化为false，通过算法将是素数的下标所对应元素值赋为true，最后输出所有为true元素的下标即可。

    普通筛——埃拉托斯特尼(Eratosthenes)筛法

用一个长度为N+1的数组保存信息（true表示素数，false表示非素数），先假设所有的数都是素数（初始化为true），从第一个素数2开始，把2的倍数都标记为非素数（置为false），一直到大于N；然后进行下一趟，找到2后面的下一个素数3，进行同样的处理，直到最后，数组中依然为true的数即为素数。

#include<stdio.h>
#include<stdbool.h>
#define N 100
int main(void)
{
    bool number[N+1];
    int i,j;
    memset(number,true,sizeof(number));
    for(i=2;i<=sqrt(N);i++)
    {
        if(number[i]==true)//如果i是素数
        {
            for(j=2;j*i<=N;j++)
            {
                number[i*j]=false;//如果i是素数，则i*j不是素数
            }
        }
    }//所有非素数都标记为false，素数都标记为true
    for(i=2;i<N+1;i++)
        if(number[i]==true)
            printf("%d ",i);//输出所有素数
    return 0;
}

此筛选法的时间复杂度是O(nloglogn)

关于算法改进：

#include<stdio.h>
#include<stdbool.h>
#define N 100
int main(void)
{
    bool number[N+1];
    int i,j;
    memset(number,true,sizeof(number));
    for(i=2;i<=sqrt(N);i++)
    {
        if(number[i]==true)//如果i是素数
        {
            for(j=i*i;j<=N;j+=i)
            {
                number[j]=false;//二次筛选法:i是素数，则下一个起点是i*i,把后面的所有的i*i+2*n*i筛掉
            }
        }
    }//所有非素数都标记为false，素数都标记为true
    for(i=2;i<N+1;i++)
        if(number[i]==true)
            printf("%d ",i);//输出所有素数
    return 0;
}

   

3.线性筛——欧拉Euler筛(时间复杂度为O(n)）

上面介绍的筛法效率很高，但不足之处也比较明显，手动模拟一遍就会发现，很多数被处理了不止1遍，因此又造成了比较大的不必要处理。下面就是改进之后的筛法：

#include<stdio.h>
#include<stdbool.h>
#define N 100
int main(void)
{
    bool number[N+1];
    int prime[N+1];
    int i,j,count=0;
    memset(number,true,sizeof(number));
    for(i=2;i<=N;i++)
    {
        if(number[i])
            prime[count++]=i;
        for(j=0;j<count&&prime[j]*i<=N;j++)
        {
            number[prime[j]*i]=false;
            if(i%prime[j]==0)//精华就在于此：它保证每个合数只会被它的最小质因数筛去，因此每个数只会被标记一次，所以时间复杂度是O(n)
                break;
        }
    }
    for(i=2;i<N+1;i++)
        if(number[i]==true)
            printf("%d ",i);
    return 0;
}

   

    以上就是笔者整理的关于求素数的算法，有很多不足之处希望各位大神的批评指正。

一些想法：

1.   如何确定素数的分布范围

有时我们可能会诸如遇到求n个素数而不是n以内的素数这样的问题。这就需要素数定理的帮助了。

素数定理：素数的分布是越往后越稀疏。或者说，素数的密度是越来越低。而素数定理，说白了就是数学家找到了一些公式，用来估计某个范围内的素数，大概有几个。在这些公式中，最简洁的就是 x/ln(x).假设要估计1,000,000以内有多少质数，用该公式算出是72,382个，而实际有78,498个，误差约8个百分点。该公式的特点是：估算的范围越大，偏差率越小。一般用x/ln x来估计某个范围内素数的个数(误差小于15%)

2.    整形数组与布尔型数组

布尔类型只占据一个字节，因此占用内存要小。但有些程序猿会想出按位（bit）存储的思路。这其实是在以上思路的基础上，优化了空间性能。C/C++出身的或者是玩过汇编语言的，比较容易往这方面想。
以C为例，一个bool占用1字节内存。而1个字节有8个比特，每个比特可以表示0或1。所以，当你使用按位存储的方式，一个字节可以拿来当8个布尔型使用。所以，达到此境界的程序猿，会构造一个定长的byte数组，数组的每个byte存储8个布尔值.空间性能相比上者提高8倍。