首先,我们谈一下素数的定义,什么是素数?除了1和它本身外,不能被其他自然数整除(除0以外)的数
称之为素数(质数);否则称为合数。
根据素数的定义,在解决这个问题上,一开始我想到的方法是从3到N之间每个奇数进行遍历,然后再按照素数的定义去逐个除以3到
根号N之间的奇数,就可以计算素数的个数了。
于是便编写了下面的代码:
(代码是用C++编写的)
#include<iostream> #include <time.h> using namespace std; #define N 1000000 int compuPrimeN(int); int main(char argc, char* argv[]) { int iTimeS = clock(); int iNum = compuPrimeN(N); int iTimeE = clock(); cout << iNum << endl; cout << "算法时间:" <<iTimeE - iTimeS<<"毫秒"<< endl; getchar(); return 0; } int compuPrimeN(int maxNum) { //算法1 int iNum = 1; //起始记上2 bool bPrime = true; for (int i = 3; i <= maxNum; i += 2) { bPrime = true; for (int j = 3; j <= (int)sqrt(i); j += 2) { if (i%j == 0) { bPrime = false; break; } } if (bPrime) iNum++; } return iNum; }
运行后如图所示:
由此可见,算法的性能不是很好,在时间上还有很大可以优化的空间。
那么,该如何优化?
首先,我是想,既然去掉了2的倍数,那么能不能去掉3的倍数,但后来
发现,在第二个循环里第一个取余的就是3,那么3的倍数其实只计算了一次
就过滤,所有没有必要再往下思考。
后来我想到,在第二个循环里,3取余过了,如果没跳出循环,那么6,9之类的
应该不用继续取余,同理,5取余过了,那么10,15...就不该继续取余,因为取余
5不为0,那么取余10,15肯定也不为0.换言之,那么不该取余的其实是合数!!
why?因为如果是合数,那么比他根号本身小的数里肯定有它能取余的,也就是
之前我们想过滤掉不想取余的数,这样一来,其实我们只要在第二循环里取余
比其根号本身要小的质数就能判断出来了!而那些质数我们在求该数之前就已经
找出来了,那么我们只要将其记录下来就行了!!
于是乎,遵循乎该思路,我将compuPrimeN()函数重写,写出了第2个算法:
int compuPrimeN(int maxNum) { //算法2 int iNum = 1; //记录素数总个数 int iRecN = 1; //记录在数组内素数的个数 bool bPrimeN = true; int sqrtMaxN = (int)sqrt(maxNum); //我们要记录小于sqrtMaxN内的素数,为使空间分配最优,大小为x/ln(x)*1.2, //因为科学家发现一个求素数大致范围的近似公式x/ln(x), //为了不数组越界,多加20%范围 //注意maxNum为3时为特例,因为此处ln(根号3)为0 int* iPrime = new int[maxNum == 3 ? 1 : (int)((float)sqrtMaxN / log(sqrtMaxN)*1.2)]; for (int i = 3; i <= maxNum; i += 2) { bPrimeN = true; //只要取余范围内的素数就好了 for (int j = 1; j < iRecN; j++) { if (i%iPrime[j] == 0) { bPrimeN = false; break; } } if (bPrimeN) { if (i <= sqrtMaxN) { iPrime[iRecN] = i; iRecN++; iNum = iRecN; } else iNum++; } } delete iPrime; return iNum; }
运行后如图所示:
看,优化后算法的时间性能比原来好了19倍左右,
那能不能更快呢?
我想理论上是可以的,因为前面的算法都用到了一种思想,
事先过滤掉了2,3的倍数,如果我们能把5,7,11的倍数都
事先过滤掉那不是更快吗?
这里为什么没有9,因为9的倍数即是3的倍数啊,咦?好像
发现了什么,和算法2的思想有点类似,如果我们能事先过滤掉
质数倍数,那么不是能过滤掉很多合数了吗,而对于该质数+1,
无非是两种情况,其一是它是被过滤掉的合数,其二是它是质数,
否则它应该在之前过滤掉的啊!!而我们只要在过滤的过程中,
把遇到的不能过滤的统计起来,不就是我们所求的质数吗?
这样一来,时间性能不是能更进一步优化了吗?对,但是要事先
过滤掉这么多的合数,并将其行为记录下来,就要消耗极大的
空间了,这就是典型的空间换时间!!
于是,我写的算法3便诞生了,如下:
int compuPrimeN(int maxNum) { //算法3 //用bool型大数组来记录,true为素数,false为偶数 //因为求素数个数,所以前两个可以忽略. bool* bArray = new bool[maxNum + 1]; for (int i = 2; i <= maxNum; i++) bArray[i] = true; int iNum = 0; for (int i = 2; i <= maxNum; i++) { //替换筛子后面的合数为false if (bArray[i]) { iNum++; for (int j = i + i; j <= maxNum; j += i) { bArray[j] = false; } } } delete bArray; return iNum; }
运行后如图:
哇!没想到算法的时间竟然能够优化如此快速!!但是,好像耗费的空间
存储有点多,仅用bool型的数组记录似乎有点浪费,能不能在每个bit上用0或1
来代替记录呢?
于是,我又写了下面的算法:
int compuPrimeN(int maxNum) { //算法4 //用每个位0或1来分别表示合数和素数 //好处是内存空间利用最大化 int size = maxNum % 8 == 0 ? maxNum / 8 : maxNum / 8 + 1; unsigned char* array = new unsigned char[size]; for (int i = 0; i < size; i++) array[i] = 127; int iNum = 0, iBit = 0, index = 0; for (int i = 2; i <= maxNum; i++) { index = i / 8; (iBit = i % 8) == 0 ? iBit = 7, index-- : iBit--; if (array[index] & (1 << iBit)) { iNum++; for (int j = i + i; j <= maxNum; j += i) { index = j / 8; (iBit = j % 8) == 0 ? iBit = 7, index-- : iBit--; array[index] = array[index] & (~(1 << iBit)); } } } delete array; return iNum; }
运行结果如图:
虽然由于二进制的计算使其在时间性能上比算法3要慢上那么一点,
但是换做bit来记录素数或合数,却是让空间存储变为了原来的1/8,
其好处是不言而喻的,如果没有内存空间问题,那么用算法3也是
无可厚非的,如果对内存空间要求比较严格,那么算法2才是最佳
首选。
总结:
在思考和编码中,我深深的体会到了,算法优化的重要性,而要想成为
一个优秀的程序员,那么就必须明白,算法是程序的灵魂!!