定义：一个大于1的，除了1和它本身外，不能被其他自然数整除的整数，称为质数（prime number）又称素数。合数，指自然数中除了能被1和本身整除外，还能被其他数（0除外）整除的数。与之相对的是质数，而1既不属于质数也不属于合数。
问题一：判断单个数n是否为素数。
思路：如果该数大于或等于2，则遍历2到根号n区间的所有整数a，将n对a取余，如果余数全部不为0则n为质数。将上句话中的“整数a”改为“2与奇数a”、“素数a”，运算的时间越来越短。合数可以分解成若干素数的乘积。大于2的偶数已经是含有乘积项2的合数，n对其取余如果等于0则n对2取余必为0，n对其取余如果不为0则n对2取余也有可能为0，因此对大于2的偶数取余是完全多余的。同理，奇数里面也有合数，也可被分解为若干素数之积。故遍历素数最优，但这会牺牲空间记录素数。故“2与奇数a”兼具较好的时间复杂度与空间复杂度。
问题二：统计不大于N的所有素数。
思路：从2到N遍历然后用问题一解法判断，暴力解法不考虑。考虑筛选法：从2到N中筛掉合数，剩下的就是素数。怎么筛，有两种方法。
埃式筛选：
从2到N遍历，遇到素数，就筛掉这个素数的所有倍数（做上标记），这里的素数判断不用问题一的方法，凡是没被标记的数就是素数。
import java.util.Scanner;
public class Main{
public static void getPrime(int n) {
if (n <= 1) {
System.out.println("Error,N should satisfy N>1");
} else {
boolean[] flag = new boolean[n + 1];
int[] prime = new int[n];
int count = 0;
for (int i = 2; i <= n; i++) {
if (!flag[i]) {
prime[count++] = i;
for (int j = i * 2; j <= n; j += i) {
flag[j] = true;
}
}
}
System.out.println("不大于"+n+"的所有素数一共有"+count+"个：");
for (int i=0;i<count;i++) {
System.out.print(prime[i]+" ");
}
}
}
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
if (scan.hasNext()){
int N=scan.nextInt();
Main.getPrime(N);
}
}
}显而易见，空间复杂度为O(N)，时间复杂度为O(N log logN)。
分析：对每个素数a，要进行N/a次运算筛掉倍数，则总次数为N*(从 1 到 N 之间的 1/a 之和) 。(从 1 到 N 之间的 1/a 之和) 约等于 log (对所有 k 从 1 到 N 之间的 1/k 之和)，后者括号里面是 log N，所以前者就是 log logN。
该方法存在重复筛的问题，即对某个合数标记了不止一次，因此时间复杂度不是线性的。比如30 =2 * 15 =3 * 10 = 5* 6。
埃式筛法改进：
boolean[] flag = new boolean[n + 1];
int[] prime = new int[n];
int count = 0;
for (int i = 2; i <= n; i++) {
if (!flag[i]) {
prime[count++] = i;
for (int j = i * i; j <= n; j += i) {//从i*i开始稍微优化了一下，但还是存在重复筛
flag[j] = true;
}
}
}欧拉筛选：
这是一种快速线性素数筛法，避免了重复筛的问题，保证每个合数只会被它的最小质因数筛去。
public static void getPrime(int n) {
if (n <= 1) {
System.out.println("Error,N should satisfy N>1");
} else {
boolean[] flag = new boolean[n + 1];
int[] prime = new int[n];
int count = 0;
for (int i = 2; i <= n; i++) {
if (!flag[i]) {
prime[count++] = i;
}
for (int j = 0; j <count && prime[j] * i <=n; j++) {
flag[i * prime[j]] = true;
if (i % prime[j] == 0)//关键步骤
{break;}
}
}
System.out.println("不大于"+n+"的所有素数一共有"+count+"个：");
for (int i=0;i<count;i++) {
System.out.print(prime[i]+" ");
}
}
}关键步骤：对每个i不论素数与否都准备筛掉i的 小于等于i的素数 倍的数，若i是某个素数prime[j]的倍数，则i*（大于prime[j]的素数）这个数 不应该由 大于prime[j]的素数 来筛，而是应该由prime[j]来筛，故在这个地方要break，确保了每个合数只会被它的最小质因数筛去。因此该算法时间复杂度和空间复杂度都为O(N)。
问题三：统计不大于N的所有素数及素数幂。（2018春微众银行笔试）
借鉴问题二欧拉筛法的思想，可以得到一种线性时间算法。如下，通过设置三种标志位，确保每个合数只被筛一次。也可采用问题二的欧拉筛法，得到素数序列后，遍历素数取幂 来解决，这种方法就相当于第一轮先筛掉了素数幂，然后第二轮又把素数幂捡起来了。
import java.util.Scanner;//输入一个正整数，统计不大于这个数的所有素数与素数幂
public class Prime {
public static void getPrimeAndPrimePower(int n){
if(n<=1){System.out.println("Error,N should satisfy N>1");}else {
byte[] flag =new byte[n+1]; //没赋值默认为0,flag标志:合数为1,素数为0,素数幂为2
int[] prime=new int[n];
int count1=0;
int count2=n-1;
for (int i = 2; i <= n; i++) {
if (flag[i]==0) {
prime[count1++]=i;
for (int j = 0; j <count1-1 && prime[j] * i <=n; j++) {
flag[i * prime[j]] = 1; }
if(i * i <=n){flag[i*i]=2;}
}
if (flag[i]==1) {
for (int j = 0; j <count1 && prime[j] * i <=n; j++) {
flag[i * prime[j]] = 1;
if (i % prime[j] == 0)
{ break;}
}
}
if (flag[i]==2) {
prime[count2--]=i;
for (int j = 0; j <count1 && prime[j] * i <=n; j++) {
if (i % prime[j] != 0)
{flag[i * prime[j]] = 1;}
else
{ flag[i * prime[j]] = 2;
break;}
}
}
/*//3合1
if (flag[i]==0) { prime[count1++]=i;}
if (flag[i]==2) { prime[count2--]=i;}
for (int j = 0; j <count1 && prime[j] * i <=n; j++) {
flag[i * prime[j]] = 1;
if (i % prime[j] == 0)//这里是精髓
{ if(flag[i]==2){flag[i * prime[j]] = 2;}
break;}
}
if(flag[i]==0&&i*i<=n){flag[i*i]=2;}//这里将素数的平方的flag标志重新覆盖了一次*/
}
System.out.println("不大于"+n+"的所有素数与素数幂一共有"+(count1+n-count2-1)+"个：");
for (int i = 0; i <count1; i++)
{System.out.print(prime[i]+" ");}
for (int i = count2+1; i <n; i++)
{System.out.print(prime[i]+" ");}
}
}
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
if (scan.hasNext()) {
int N=scan.nextInt();
Prime.getPrimeAndPrimePower(N);
}
}
}