质数筛（普通筛、埃式筛、线性筛）

呦呦呦欸哟哟

已于 2023-03-14 22:56:03 修改

阅读量304

点赞数 1

文章标签： java 算法数据结构

于 2023-03-14 00:44:45 首次发布

本文链接：https://blog.csdn.net/xjl243636988/article/details/129510582

版权

质数筛

一、普通筛

普通筛法的时间复杂度为 O(nlogn)
筛法：从前往后，把每一个数的倍数筛掉
比如24被2，3，4，6，8，12筛去6次
例题：给定一个正整数n, 请你求出1~n中质数的个数。
输入格式：共一行，包含整数n。
输出格式：共一行，包含一个整数，表示1-n中质数的个数。
数据范围：1≤n<10^5
输入样例：8
输出样例：4

import java.util.Scanner;
public class Main {
    public static int[] primes = new int[10000010];//用来存储所有的素数
    //用来记录第i个数是不是素数，如果是素数st[i] = false，如果不是素数st[i] = ture
    //boolean的默认值为false
    //故初始情况下，默认所有数都是素数，都是false，当筛到不是素数的数时，将st[i]置为ture
    public static boolean[] st = new boolean[10000010];
    public static int count;//用来统计素数的数目

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        get_primes(n);

    }

    //普通筛法 O(nlogn)
    //即从前往后，把每一个数的倍数筛掉
    public static void get_primes(int n) {
        for (int i = 2; i <= n; i++) {
            //如果是质数
            if (st[i] == false){
                primes[count++] = i;
            }
            //不管当前i是合数还是质数，都用来筛掉后面它的倍数
            //st[j]从2*i,到3*i,一直到n,全部置为ture
            for (int j = i + i; j <= n; j += i) {
                st[j] = true;
            }
        }
        System.out.println(count);
    }
}

二、埃式筛

优化后的埃式筛的时间复杂度为 O(nloglogn)
筛法：每个合数只会被自己的最小质因子筛一次，故用每一个合数的最小质因子筛去当前合数
比如24会被2，3筛去两次
例题：给定一个正整数n, 请你求出1~n中质数的个数。
输入格式：共一行，包含整数n。
输出格式：共一行，包含一个整数，表示1-n中质数的个数。
数据范围：1≤n<10^5
输入样例：8
输出样例：4

import java.util.Scanner;
public class Main {
    public static int[] primes = new int[10000010];//用来存储所有的素数
    //用来记录第i个数是不是素数，如果是素数st[i] = false，如果不是素数st[i] = ture
    //boolean的默认值为false
    //故初始情况下，默认所有数都是素数，都是false，当筛到不是素数的数时，将st[i]置为ture
    public static boolean[] st = new boolean[10000010];
    public static int count;//用来统计素数的数目

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        get_primes(n);

    }

    //埃式筛的时间复杂度为 O(nloglogn)
    //即从前往后，把质数的倍数筛掉
    public static void get_primes(int n) {
        for (int i = 2; i <= n; i++) {
            //如果是质数
            if (st[i] == false){
                primes[count++] = i;
                //在质数的基础上，筛掉质数的倍数
                for (int j = i + i; j <= n; j += i) {//st[j]从2*i,到3*i,一直到n,全部置为ture
                    st[j] = true;
                }
            }
        }
        System.out.println(count);
    }
}

三、线性筛

线性筛法的时间复杂度为 O(n)
筛法：并不需要像上面那样从前往后，把每一个数的倍数筛掉，只需要把质数的倍数筛掉就行了
比如24只会被2筛去一次
例题：给定一个正整数n, 请你求出1~n中质数的个数。
输入格式：共一行，包含整数n。
输出格式：共一行，包含一个整数，表示1-n中质数的个数。
数据范围：1≤n<10^5
输入样例：8
输出样例：4
附上我觉得讲的很详细的大佬讲解: 点击跳转至线性筛法讲解

import java.util.Scanner;
public class Main {
    public static int[] primes = new int[10000010];//用来存储所有的素数
    //用来记录第i个数是不是素数，如果是素数st[i] = false，如果不是素数st[i] = ture
    //boolean的默认值为false
    //故初始情况下，默认所有数都是素数，都是false，当筛到不是素数的数时，将st[i]置为ture
    public static boolean[] st = new boolean[10000010];
    public static int count;//用来统计素数的数目

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        get_primes(n);
        System.out.println(count);
    }

    //线性筛法O(n)
    //每个合数只会被自己的最小质因子筛一次
    //故用每一个合数的最小质因子筛去当前合数
    public static void get_primes(int n) {
        for(int i = 2 ; i <= n ; i ++ )
        {
            if(st[i] == false){
                primes[count ++] = i;
            }
            //从小到大枚举所有的质数
            for(int j = 0 ; primes[j] <= n / i ; j ++ )
            {
                //每次把遍历到的质数与i的乘积筛掉
                st[primes[j] * i] = true;
                //当i % primes[j] == 0时：
                //说明primes[j]一定是i的最小质因子
                //primes[j]也一定是primes[j] * i的最小质因子
                //当i % primes[j] != 0时：
                //说明primes[j]一定小于i的最小质因子
                //primes[j]也一定是primes[j] * i的最小质因子
                if(i % primes[j] == 0) break;//退出循环，避免之后重复进行筛选
            }
        }
    }
}