递归迭代方法比纯迭代方法更好地找出数字是否为素数？

Question

我在C中制作了这个程序，用于测试数字是否为素数。我还不熟悉算法的复杂性和所有Big O的东西，所以我不确定我的方法，即迭代和递归的组合，实际上是否比使用纯迭代方法。

#include<stdio.h>
#include<stdlib.h>
#include<math.h>

typedef struct primenode{
    long int key;
    struct primenode * next;
}primenode;

typedef struct{
    primenode * head;
    primenode * tail;
    primenode * curr;
    unsigned long int size;
}primelist;

int isPrime(long int number, primelist * list ,long int * calls, long int * searchcalls);
primenode * primelist_insert(long int prime, primelist * list);
int primelist_search(long int searchval, primenode * searchat, long int * calls);
void primelist_destroy(primenode * destroyat);

int main(){
    long int n;
    long int callstoisprime = 0;
    long int callstosearch = 0;
    int result = 0;
    primelist primes;

    //Initialize primelist
    primes.head = NULL;
    primes.tail = NULL;
    primes.size = 0;

    //Insert 2 as a default prime (optional step)
    primelist_insert(2, &primes);

    printf("\n\nPlease enter a number: ");
    scanf("%d",&n);
    printf("Please wait while I crunch the numbers...");
    result = isPrime(n, &primes, &callstoisprime, &callstosearch);
    switch(result){
        case 1: printf("\n%ld is a prime.",n); break;
        case -1: printf("\n%ld is a special case. It's neither prime nor composite.",n); break;
        default: printf("\n%ld is composite.",n); break;
    }
    printf("\n\n%d calls made to function: isPrime()",callstoisprime);
    printf("\n%d calls made to function: primelist_search()",callstosearch);

    //Print all prime numbers in the linked list
    printf("\n\nHere are all the prime numbers in the linked list:\n\n");
    primes.curr = primes.head;
    while(primes.curr != NULL){
        printf("%ld ", primes.curr->key);
        primes.curr = primes.curr->next;
    }
    printf("\n\nNote: Only primes up to the square root of your number are listed.\n"
                "If your number is negative, only the smallest prime will be listed.\n"
                "If your number is a prime, it will itself be listed.\n\n");

    //Free up linked list before exiting
    primelist_destroy(primes.head);

    return 0;
}

int isPrime(long int number, primelist * list ,long int * calls, long int *searchcalls){
//Returns 1 if prime
//          0 if composite
//          -1 if special case
    *calls += 1;
    long int i = 2;
    if(number==0||number==1){
        return -1;
    }
    if(number<0){
        return 0;
    }
    //Search for it in the linked list of previously found primes
    if(primelist_search(number, list->head, searchcalls) == 1){
        return 1;
    }
    //Go through all possible prime factors up to its square root
    for(i = 2; i <= sqrt(number); i++){ 
        if(isPrime(i, list,calls,searchcalls)){
            if(number%i==0) return 0; //It's not a prime
        }
    }
    primelist_insert(number, list); /*Insert into linked list so it doesn't have to keep checking
                                                if this number is prime every time*/
    return 1;
}

primenode * primelist_insert(long int prime, primelist * list){
    list->curr = malloc(sizeof(primenode));
    list->curr->next = NULL;

    if(list->head == NULL){
        list->head = list->curr;
    }
    else{
        list->tail->next = list->curr;
    }
    list->tail = list->curr;
    list->curr->key = prime;
    list->size += 1;

    return list->curr;
}

int primelist_search(long int searchval, primenode * searchat, long int * calls){
    *calls += 1;
    if(searchat == NULL) return 0;
    if(searchat->key == searchval) return 1;
    return primelist_search(searchval, searchat->next, calls);
}

void primelist_destroy(primenode * destroyat){
    if(destroyat == NULL) return;
    primelist_destroy(destroyat->next);
    free(destroyat);
    return;
}

基本上，我所看到的很多简单的primalty测试都是： 0.2是素数。 1.循环遍历从2到一半的所有整数或被测数字的平方根。 2.如果数字可被任何部分整除，则中断并返回false;这是复合材料。 3.否则，在最后一次迭代后返回true;这是最好的。

我认为您不必测试从2到平方根的每个数字，只需测试每个 prime 数字，因为所有其他数字都是素数的倍数。因此，在使用模数之前，函数调用自身以查明数字是否为素数。这有效，但我认为一遍又一遍地测试所有这些素数有点乏味。 因此，我使用链接列表来存储其中的每个素数，因此在测试primalty之前，程序首先搜索列表。

真的更快，更有效率，还是我浪费了很多时间？我在我的计算机上测试了它，而对于较大的素数，它确实看起来更快，但我不确定。我也不知道它是否使用了更多的内存，因为无论我做什么，任务管理器都会保持0.7 MB不变。

感谢您的回答！

Answer 1

由于您的程序只测试一个数字，因此您在浪费时间尝试避免使用复合材料进行测试。您执行了大量计算以保存一个微小的模运算。

如果你连续测试多个数字以获得素数，那么预先计算素数到该范围上限的sqrt是有意义的，并在测试候选时通过这些素数

最好还是执行偏移 sieve of Eratosthenes（C code here），以找到给定范围内的素数。 Eratosthenes筛子从2到N找到素数的时间复杂度为O(N log log N);并且试验除以素数，O(N^1.5 / (log N)^2)（更差;例如the ratio of run times筛分高达1mln，而100k为10.7x，而试验师为22x; 2mln对1ml是筛选2.04倍，试验分割2.7倍。

Eratosthenes偏移筛的伪代码：

Input: two Integers n >= m > 1

Let k = Floor(Sqrt(n)),
Let A be an array of Boolean values, indexed by Integers 2 to k, and
    B an array of Booleans indexed by Integers from m to n,
    initially all set to True.

for i = 2, 3, 4, ..., not exceeding k:
  if A[i] is True:
    for j = i^2, i^2+i, i^2+2i, ..., not greater than k:
      A[j] := False
    for j = i^2, i^2+i, i^2+2i, ..., between m and n, inclusive:
      B[j] := False

Output: all `i`s such that B[i] is True, are all the primes 
                                     between m and n, inclusive.

常见的优化是仅使用赔率，i = 3,5,7,...，从一开始就避免任何偶数（无论如何已知2是素数，任何偶数都是复合数）。然后2i的步骤，而不仅仅是i，可以在两个内循环中使用。因此，偶数索引被完全排除在处理之外（通常采用压缩寻址方案，val = start + 2*i）。

Answer 2

以下代码段可以大大提升：

//Go through all possible prime factors up to its square root
for(i = 2; i <= sqrt(number); i++){ 
    if(isPrime(i, list,calls,searchcalls)){
        if(number%i==0) return 0; //It's not a prime
    }
}

不要循环遍历所有数字，只需循环浏览链接列表中的数字：

// Go through all possible prime factors up to its square root
primenode *p;
for (p = primes.head; p->key <= sqrt(number); p = p->next) { 
        if (number%(p->key) == 0) return 0; //It's not a prime
    }
}