埃拉托色尼筛法用于求一定范围内的素数。

第一种方法:

原理是在数组元素中存放数值,若判定为非素数则将其值修改为0,输出时会跳过值为0的元素。

   
   
   
   
  1. //埃拉托色尼筛法  
  2.   
  3. #include  
  4. #include   
  5. #define NUM 100 
  6. #define W 2 
  7. using namespace std; 
  8.   
  9. int main(int argc,char * argv[]) 
  10.     int array[NUM/2]; 
  11.     int sign,flag; 
  12.   
  13.     //给数组赋值 
  14.     for(sign=0,flag=3;sign
  15.     { 
  16.         array[sign]=flag; 
  17.         flag+=2; 
  18.     }  
  19.   
  20.     //对数组进行筛选 
  21.     for(sign=0;sign
  22.     { 
  23.         if(array[sign]) 
  24.         { 
  25.             for(flag=sign+1;flag<49;flag++) 
  26.             { 
  27.                 if(!(array[flag]%array[sign])) 
  28.                 { 
  29.                     array[flag]=0; 
  30.                 } 
  31.             } 
  32.         } 
  33.     }  
  34.   
  35.     //输出素数组 
  36.     cout<<"100以内的素数有:\n 2\t"
  37.     flag=1; 
  38.     for(sign=0;sign
  39.     { 
  40.         if(array[sign]) 
  41.         { 
  42.             cout<'\t'
  43.             flag+=1; 
  44.             if(!(flag%5)) 
  45.             { 
  46.                 cout<
  47.             } 
  48.         } 
  49.     }  
  50.     cout<
  51.   
  52.     return 0; 

代码中会反复出现 NUM/2-1 的原因:
if sign<=50 最后判断的数字为 3+2*50=103 超出了上限100
if sign<=49 最后判断的数字为 3+2*49=101 超出了上限100
if sign<49(即sign<=48) 最后判断的数字为 3+2*48=99 在范围之内
至于为什么是 NUM/2-1 ,在原理上想不通怎么解释,只是在运行过程中观察结果得出的结论。

另一种方法:

用数组的下标存放数值,数组中各元素的值用0和1表示是不是素数。最终输出值为1的数组元素的下标。
原理是,发现一个数,然后在后面的所有数中删除它的倍数(赋值为0)。

   
   
   
   
  1. //埃拉托色尼筛法  
  2.   
  3. #include  
  4. #include  
  5. #define N 100 
  6. #define W 2 
  7. using namespace std; 
  8.   
  9. int main(int argc,char *argv[]) 
  10.     int array[N]={0},sign,flag,i=0; 
  11.   
  12.     cout<"以内的素数有:"<
  13.     for(sign=2;sign
  14.     { 
  15.         if(array[sign]==0) 
  16.         { 
  17.             cout<" "
  18.             i++; 
  19.             //每输出5个值后换行  
  20.             if(i%5==0) 
  21.             { 
  22.                 cout<
  23.             } 
  24.         } 
  25.         for(flag=1;sign*flag<=N;flag++) 
  26.         { 
  27.             array[sign*flag]=1; 
  28.         } 
  29.     } 
  30.   
  31.     return 0;