素数算法的不同等级

题目：求小于等于自然数N（N>=2）内的所有素数。 

等级一：

[html] view plain copy

1. int nFlag = 10000;  
2. int nCount = 0;  
3. for(int i = 2; i<=nFlag; i++)  
4. {         
5.     bool bSS = true;          
6.     for(int j = 2; j<i; j++)  
7.     {  
8.         if(i%j == 0)  
9.         {  
10.             bSS = false;  
11.             break;  
12.         }  
13.     }  
14.     if(bSS)  
15.     {  
16. /           cout<<i<<'\t';  
17.         nCount++;  
18.     }  
19. }  

N=10000，运行时间是21 ms

等级二：

优化：所有偶数中，只有2是素数

[html] view plain copy

1. int nFlag = 10000;  
2.   
3.     int nCount = 1;  
4.     for(int i = 3; i<=nFlag; i+=2)  
5.     {         
6.         bool bSS = true;          
7.         for(int j = 3; j<i; j+=2)  
8.         {  
9.             if(i%j == 0)  
10.             {  
11.                 bSS = false;  
12.                 break;  
13.             }  
14.         }  
15.         if(bSS)  
16.         {  
17. //          cout<<i<<'\t';  
18.             nCount++;  
19.         }  
20.     }  

N=10000，运行时间是10 ms

等级三：

优化：公约数都是成对出现的，所以只要小于sqrt(i)里没有整除的数即可。

[html] view plain copy

1.     int nFlag = 10000;  
2.   
3.     int nCount = 1;  
4.     for(int i = 3; i<=nFlag; i+=2)  
5.     {         
6.         bool bSS = true;  
7.         float fSqrt = sqrt((float)i);  
8.         for(int j = 3; j<=fSqrt; j+=2)  
9.         {  
10.             if(i%j == 0)  
11.             {  
12.                 bSS = false;  
13.                 break;  
14.             }  
15.         }  
16.         if(bSS)  
17.         {  
18. //          cout<<i<<'\t';  
19.             nCount++;  
20.         }  
21.     }  

N=10000，结果是：1229 运行时间是0.33 ms

等级四：

优化：只需要确保不能整除小于sqrt(i)的所有素数即可。

[html] view plain copy

1. int nFlag = 10000;  
2.     vector<int> vctInt;  
3.   
4.     vctInt.push_back(2);  
5.     for(int i = 3; i<=nFlag; i+=2)  
6.     {         
7.         bool bSS = true;  
8.         float fSqrt = sqrt((float)i);  
9.         for(int j = 0; vctInt[j]<=fSqrt; j++)  
10.         {  
11.             if(i%vctInt[j] == 0)  
12.             {  
13.                 bSS = false;  
14.                 break;  
15.             }  
16.         }  
17.         if(bSS)  
18.         {  
19. //          cout<<i<<'\t';  
20.             vctInt.push_back(i);  
21.         }  
22.     }  

N=10000，结果是：1229 运行时间是0.28 ms  （这里应该在vector的管理上花费了不少时间）

N=100000000，结果是：5761455  运行时间是25.7  s

等级五：

优化：用内存标记存储素数.

[html] view plain copy

1. int nSet = 100000000;  
2.     byte *bFlag = new byte[nSet+1];  
3.     memset(bFlag, 0, sizeof(byte)*nSet);  
4.     bFlag[0] = bFlag[1] = 1;  
5.     int nCout = 1;  
6.     int nSqrt = (int)sqrt((float)nSet);  
7.   
8.     for(int j = 2; j<=nSet; j+=2)  
9.     {     
10.         bFlag[j] = 1;  
11.     }  
12.     for(int i = 3; i<=nSet; i+=2)  
13.     {  
14.         if(!bFlag[i])  
15.         {  
16.             int nStart = i;           
17.             if(i<=nSqrt)  
18.                 nStart *= i;  
19.             nCout++;  
20.             for(int j = nStart; j<=nSet; j += 2*i)  
21.             {  
22.                 if(!bFlag[j])  
23.                     bFlag[j] = 1;  
24.             }  
25.         }         
26.     }     
27.     delete []bFlag;  

N=100000000，结果是：5761455  运行时间是2458 ms

等级六：

优化：从小到大，每找到一个新的素数s，只需将s*h(s*h<N)的标记置为1即可。（h为大于等于s的所有标记尚且为0的数）

[html] view plain copy

1. int nSet = 100000000;  
2.     byte *bFlag = new byte[nSet+1];  
3.     memset(bFlag, 0, sizeof(byte)*nSet);  
4.     bFlag[0] = bFlag[1] = bFlag[2] = 1;  
5.     int nCout = 1;  
6.     int nSqrt = (int)sqrt((float)nSet);  
7.   
8.     for(int j = 2; j<=nSet; j+=2)  
9.     {     
10.         bFlag[j] = 1;  
11.     }  
12.     for(int i = 3; i<=nSet; i+=2)  
13.     {  
14.         if(!bFlag[i])  
15.         {             
16.             nCout++;              
17.             if(i <= nSqrt+1)  
18.             {     
19.                 for(int j = nSet/i%2 ? nSet/i: nSet/i-1; j>=i; j -= 2)  
20.                 {                 
21.                     if(bFlag[j] == 0)  
22.                         bFlag[i*j] = 1;  
23.                 }  
24.             }             
25.         }         
26.     }  
27.     cout<<"Count Num:"<<nCout<<endl;  
28.     delete []bFlag;  

N=100000000，结果是：5761455  运行时间是1172ms

ps:

1.有人说上面的BYTE用了8个bit来表示是否是质数，很浪费内存。用bit位就可以了。确实如些。不过对位的操作会让程序慢很多（经测试大约3倍耗时），有利有弊吧。

2.此文章是几年前我写在另一个帐号上的，现在转过来放这里吧。耗时用现在电脑跑比以前快许多，仅参考。