一个空间换时间算法

说起空间换时间,想到c/c++语言的话我会想到#define宏定义和内联函数,他们都减少了函数切换时的压栈清栈等工作.对一个简短的函数,的确这些额外的消耗太浪费了.对于"计算素数"的问题,是一个经典的此类问题.

我们常用来找一个范围内的素数(质数)的办法有两种:
(1)筛选法
(2)判定法,即定义法

如:求1—100间的所有素数。
分析：
用筛选法，先把2—100的数存到一个数组中，然后先把2的所有倍数删除掉（即让此数变为0），再删3的倍数，继续往上就是5的倍数，7的倍数……，最后，剩下的数(即数组中不为0的数)就是素数。

用判定法,对2-100内的每个数,根据素数的定义,除本身外没有其它约数来判定是否为素数.这个有个注意的地方是:找约数的时候不用找到n,也不用找到n/2,只要到sqrt(n)就行了.[别问为什么?自己想去咯.] 具体是<?, 这里有int 和double 的比较,有写sqrt(n)+1,也看到有人写sqrt(n+1) 的,哪个是正解自己多思考呵.

验证:
以下是筛选法代码:

long filter(int end)  //method:  filter  1..end
{
    start = time(NULL);
    
    long count = 0;
    long len = end +1;
    int i,j,k;

    if(end<2) return 0;

    //生成筛选集
    int* p = new int[len];
    if(p == NULL) return 0;
    for(i=0; i<len; ++i){
        p[i] = i;
    }
    
    
    //筛选算法
    k = 2;    //作为筛选的除数
    i = k;
    int max_test = sqrt(end) + 1;
    while(i< max_test){
        for(j=k+1; j<len; ++j)
        {
            if(0 == p[j])
                continue;
            else if(p[j] % i ==0) {
                p[j] = 0;
            }
                
        }
        for(j=k+1;j<len;++j)
        {
            if(p[j] != 0){
                k = j;
                break;
            }
        }
        i = k;
    }


    //打印结果
    for(i=2;i<end;++i)
        if(p[i] != 0) 
        {
            count++;
            //printf("%d\t",p[i]);
        }
    end = time(NULL);

    printf("\nit takes your %f seconds in filter.\n",difftime(end,start));
    printf("filter(end): count = %ld",count);
    delete[] p;


    return count;

}

以下是判定法代码:

long judge(int beg, int end)  //method: judge every number
{
    start = time(NULL);
    int count = 0;

    if(beg>end || beg<1) return 0;
    
    register int i;
    while(beg<end+1)
    {
        for(i=2;i<sqrt(beg)+1; ++i){
            if(beg % i ==0) break;
        }
        if(i>sqrt(beg)) 
        {//    printf("%d\t",beg);
            count++;
            //NULL;
        }
        beg++;

    }

        
    end = time(NULL);

    printf("\nit takes your %f seconds in judge.\n",difftime(end,start));
    printf("judge(end): count = %ld\n",count);
    return count;
}

下面看我们的结果:
我测试了从1-1000000内的素数:  耗时和统计结束如下:

it takes your 2.000000 seconds in filter.
filter(end): count = 78498
it takes your 5.000000 seconds in judge.
judge(end): count = 78498
Press any key to continue

这说明在N很大时,筛选法体现出了它的高效.在N比较小时,则看不出来其明显优势咯.筛选法用了很多的内存放要被处理的数据.但是此算法对内存的访问是顺序的,在经过有选择的取出除数(筛选器?)来否定一些保留一些.经过相对比较少的次数完成了对全部数据的筛选工作.在算法复杂度上,尽管还是O(n^2)[与判定法没有什么区别],但事实在其执行次数和访问速度得到了很大的提高.

当然,以上的筛选算法还是可以再改进一下的.

long filter2(int end)  //method:  filter  1..end
{
    start = time(NULL);
    
    long count = 0;
    long len = (end +1)/2;
    int i,j,k;

    if(end<2) return 0;

    //生成筛选集
    int* p = new int[len];
    if(p == NULL) return 0;
    for(i=0; i<len; ++i){
        p[i] = i*2+1;
    }
    
    
    //筛选算法
    k = 1;    //作为筛选的除数在数组中的下标
    i = k;
    int max_test = sqrt(end) + 1;
    while(p[i]< max_test){
        for(j = k+1;j<len;++j)
        {
            if(0 == p[j])
                continue;
            else if(p[j] % p[i] ==0) {
                p[j] = 0;
            }
                
        }
        for(j=k+1;j<len;++j)
        {
            if(p[j] != 0)
            {
                k = j;
                break;
            }
        }
        i = k;
    }


    //打印结果
    for(i=1;i<len;++i)
        if(p[i] != 0) 
        {
            count++;
        //    printf("%d\t",p[i]);
        }
    end = time(NULL);

    printf("\nit takes your %f seconds in filter.\n",difftime(end,start));
    printf("filter2(end): count = %ld",count);
    delete[] p;


    return count;

}

以上的算法没有实质改进,不过其所用的内存少了一半,在进行比较等操作时循环也只有原来一半,所用的总时间和上面的筛选算法比也只是一半多一点,我觉得最重要的是,申请的内存少了,函数失败可能性变少,而且这个改进是比较有必要的,若任由它作无谓的计算,我会很心痛咯.呵呵.

注:虽然因判定法只用了几个变量,我想声明为寄存器变量,可是你知道的,"尽可能"并不是"一定",何况即使得到了,还不够快.硬件和软件算法的改善都有效果，硬件要成本，算法要技术。怎么办？掠拌.