PHP输出1到n所有素数及素数和的三种算法

素数是只能被1和本身整除的数
下面用PHP输出1到n所有素数及素数和

1.普通算法：

思路：给定数n，得到2到n之间所有的数，然后依次判断其中的每一个数——能否被2到该数-1整除，如果被整除，则该数不为素数
算法如下：

<?php
function primes($n, $s = false){
	$primes = array();
	//$i就是2到$n所有的数
	for($i = 2; $i <= $n; $i++){
		//每次循环都将标志设为true
		$sign = true;
		//$j就是2到$i之间的数能否被整除
		for($j = 2; $j < $i; $j ++){
			//判断$i能否被$j整除
			if ($i % $j == 0) {
				//如果被整除，将标志改为false
				$sign = false;
				//跳出循环
				break;
			}
		}
		if ($sign) $primes[] = $i;//将判断为素数的$i存入数组
	}
	//条件判断，是否需要求和
	if($s){
		//遍历数组，取出键值
		foreach ($primes as $value) {
			//累加
			$sum += $value;
		}
		//将和以sum为键名存入数组
		$primes['sum'] = $sum;
	} 
	//返回数组
	return $primes;
}
echo '<pre>';
print_r(primes(100000,true));

以PHP默认运行时间30s和运行消耗内存128M为标准，这个算法跑到输出1到110000之间的素数就超过了最大运行时间30S。

接下来考虑算法优化问题：
考虑到素数都是奇数，因此外层循环也没必要执行n-1次，因为2到n里面含有偶数，所以不用使$i每次自增1，改为自增2，这样做的话就要在初始数组中放入值为2的单元。考虑了外层循环，那内层循环呢？同理！

于是算法1可以优化为下列算法：

<?php
function primes($n, $s = false){
	//初始化数组
	$primes = array(2);
	//$i就是3到$n所有的数，
	for($i = 3; $i <= $n; $i += 2){
		//每次循环都将标志设为true
		$sign = true;
		//自增2遍历奇数
		for($j = 3; $j < $i; $j += 2){
			//判断$i能否被$j整除
			if ($i % $j == 0) {
				//如果被整除，将标志改为false
				$sign = false;
				//跳出循环
				break;
			}
		}
		//将判断为素数的$i存入数组
		if ($sign) $primes[] = $i;
	}
	//条件判断，是否需要求和
	if ($s) {
		//初始化求和数
		$sum = 0;
		//遍历数组
		foreach ($primes as $value) {
			//累加
			$sum += $value;
		}
		//将和以sum为键名存入数组
		$primes['sum']=$sum;
	} 
	//返回数组
	return $primes;
}
echo '<pre>';
print_r(primes(150000, true));

这个算法跑到输出1到170000之间的素数就超过了最大运行时间30S

那继续考虑算法优化问题：
既然要求素数，也就是在1到n的自然数中排除合数，合数有这个性质：将合数质因数分解，必然有一个质因数大于1小于该合数的平方根。证明如下：

假设某合数b=a1*a2*a3*...*ak（均为质数）
设a1为最小质因数,则an=b/a1为另一质数
因为a1为最小质因数
所以b/a1>a1,即b>a1^2
即sqrt(b)>a1

所以算法第6行可以这样写：

for($j = 3; $j <= sqrt($i); $j += 2);

这个算法可以输出1到3500000之间的素数，之后就会超过最大运行时间30S

2.试除算法

判断一个数是否为素数有一个方法：使用小于这个数的所有素数依次试除，若所有试除都有余数，则该数也为素数
按照算法1第一步优化，排除掉偶数，算法如下：

function primes($n, $s = false){
	//初始化数组
	$primes = array(2);
	//$i就是3到$n所有的奇数
	for($i = 3; $i <= $n; $i += 2){
		//得到数组长度
		$len = count($primes);
		//标志初始化，每次循环都会变为true
		$sign = true;
		//试除
		for($j = 0; $j < $len; $j ++){
			if ($i % $primes[$j] == 0) {
				//标志变为false
				$sign = false;
				//跳出循环
				break;
			}
		}
		//将$i的值存入数组
		if ($sign) $primes[$j] = $i;
	}
	//条件判断
	if ($s) {
		//初始化求和数
		$sum = 0;
		//遍历数组
		foreach ($primes as $value) {
			//累加
			$sum += $value;
		}
		//将和以sum为键名存入数组
		$primes['sum'] = $sum;
	} 
	//返回数组
	return $primes;
}
echo '<pre>';
print_r(primes(325000,true));

这个算法可以输出1到325000之间的所有素数，之后就会超过最大运行时间30S

3.指针筛选法

考虑算法1的全部优化过程，排除了偶数，也就是2的倍数，是不是也能排除3的倍数，5的倍数，即质数的倍数，再考虑质因数，是不是也能用最小质因数小于sqrt($n)呢。
这里使用的方法就是筛选法：

筛选法又称筛法，具体做法是：先把N个自然数按次序排列起来。1不是质数，也不是合数，要划去。第二个数2是质数留下来，而把2后面所有能被2整除的数都划去。2后面第一个没划去的数是3，把3留下，再把3后面所有能被3整除的数都划去。3后面第一个没划去的数是5，把5留下，再把5后面所有能被5整除的数都划去。这样一直做下去，就会把不超过N的全部合数都筛掉，留下的就是不超过N的全部质数。因为希腊人是把数写在涂腊的板上，每要划去一个数，就在上面记以小点，寻求质数的工作完毕后，这许多小点就像一个筛子，所以就把埃拉托斯特尼的方法叫做“埃拉托斯特尼筛”，简称“筛法”。（另一种解释是当时的数写在纸草上，每要划去一个数，就把这个数挖去，寻求质数的工作完毕后，这许多小洞就像一个筛子。）来源于百度百科：筛选法

于是就有了以下算法：

<?php
function primes($n, $s=false){
	//填充键名从2开始，值为'prime'的数组，共有n-1项，认为所有项都为质数
	$primes=array_fill(2, $n-1, 'prime');
	//确定范围
	for($i = 2, $range = sqrt($n); $i <= $range ; $i ++){
		//指针操作，从2开始，选定值为'prime'的单元
    	if (each($primes)[1] === 'prime') { 
    		//得到所有选定值倍数的键名
        	for($j = 2*$i ; $j <= $n; $j += $i){ 
        		//删除该单元
            	unset($primes[$j]);
       		}
    	}
	}
	//将primes数组所有键名作为值替换primes数组所有的值，方便下一步求和
	$primes=array_keys($primes);
	//条件判断
	if ($s) {
		//初始化求和数
		$sum=0;
		//遍历数组
		foreach ($primes as $value) {	
		//求和		
			$sum += $value;
		}
		//将和以sum为键名存入数组
		$primes['sum'] = $sum;
	} 
	//返回数组
	return $primes;
}
echo '<pre>';
//memory max2350000
print_r(primes(150000,true));

这个是想到的更完美的算法，以空间复杂度换时间复杂度，能输出1到2350000的所有质数，之后的会因为第三行填充数组消耗太多内存而不能进行其他运算（128M），但是运行效率比算法1最后优化的要快很多。

4.算法对比

这里主要对比算法1最后优化的算法和算法3
设定time_limit为无限，内存为10GB。
以下列简单代码粗略计算时间

<?php
$startTime = time();
include('primes/primes2.php');//include('primes/primes3.php');
//primes2.php为算法1最后优化算法
//primes3.php为算法3
$endTime = time();
$processTime = $endTime - $startTime;
echo $processTime;

输出1到10000000的质数（毕竟战斗才是男人的浪漫！）：
算法1消耗时间(输出的processTime)：138s
算法3消耗时间(输出的processTime)：10s