使用遞歸C ++查找半素數

Question

有什么辦法可以將其轉換為遞歸形式？ 如何找到未知的素因數（如果是半素數）？

semiPrime function:

bool Recursividad::semiPrimo(int x)
{
    int valor = 0;
    bool semiPrimo = false;
    if(x < 4)
    {
        return semiPrimo;
    }
    else if(x % 2 == 0)
    {
        valor = x / 2;
        if(isPrime(valor))
        {
            semiPrimo = true;
        }
    }
    return semiPrimo;
}

編輯：我已經部分解決方案（不是遞歸形式）。 我知道我必須使用尾遞歸，但是在哪里？

   bool Recursividad::semiPrimo(int x){
    bool semiPrimo=false;
vector<int> listaFactores= factorizarInt(x);
vector<int> listaFactoresPrimos;
int y = 1;

for (vector<int>::iterator it = listaFactores.begin();
            it!=listaFactores.end(); ++it) {
                if(esPrimo(*it)==true){
            listaFactoresPrimos.push_back(*it);         
        }
    } 
int t=listaFactoresPrimos.front();
if(listaFactoresPrimos.size()<=1){  
    if(t*t==x){
    semiPrimo=true;
    }
}else{
    int f=0;
    #pragma omp parallel 
    {
     #pragma omp for
    for (vector<int>::iterator it = listaFactoresPrimos.begin();
            it!=listaFactoresPrimos.end(); ++it) {
                f=*it;
                int j=0;
                for (vector<int>::iterator ot = listaFactoresPrimos.begin();
            ot!=listaFactoresPrimos.end(); ++ot) {
                j=*ot;

                if((f * j)==x){
                            semiPrimo=true;         }

                }

    } 
    }
}
return semiPrimo;
}

任何幫助，將不勝感激

Answer 1

您可以按公式方式將循環轉換為遞歸。 注意， do_something()不必是單個函數調用； 它可以是任何東西（除了可以改變循環行為的break類的流控制之外）：

void iterative() {
    for (int x = 0; x < 10; ++x) {
        do_something(x);
    }
}

變成

void recursion_start() {
    recursive(0);
}

void recursive(int x) {
    if (x < 10) {
        do_something(x);
        recursive(x + 1);
    }
}

還要注意，您可以按照以下方式重寫該代碼，它在一個好的編譯器中實際上將以與迭代版本一樣快的速度運行（這稱為“尾調用優化”）。 例如，gcc 4.6.2可以做到這一點-實際上，它足夠聰明，也可以執行上述版本。

void recursive(int x) {
    if (x >= 10)
        return;
    do_something(x);
    recursive(x + 1);
}

Answer 2

實際上，您的算法並不是實現它的最佳方法。 如果x大於100，則您的程序將失敗。

檢驗數是否為素數的天真的算法是試算法 。 遞歸實現：

bool is_prime_rec(int x, int it = 2)
{
    if (it > sqrt(double(x)))
        return true;
    return x%it ? is_prime_rec(x, ++it) : false;
}

但是，如果將循環替換為循環，它將看起來更好：

bool is_prime(int x)
{
    if (x == 2)
        return true;
    if (x%2 == 0)
        return false;

    // speed up a bit
    for (int i = 3; i <= sqrt(double(x)); i += 2) 
        if (x%i == 0)
            return false;
    return true;
}

Answer 3

查找從1到n的質數的常見答案是Erasthones篩 。 但是首先，您需要弄清楚如何確定數字是否為半素數。 如果需要，您可以捕獲從1到7的瑣碎情況。 之后，只需運行篩子並檢查每個質數作為除數即可。 如果它是偶數除數，並且商也位於質數列表中，那么您就是黃金。 如果它不在您的質數列表中（並且尚未通過篩子到達），則將其添加到可能性列表中，並在生成足夠高的質數時對其進行檢查。 一旦找到兩個素數，就成功退出。 如果達到數字除以最小除數，則失敗退出。

Catch是，我想不出一種在遞歸上實現此功能且不會損害性能的方法。 也就是說，您可以將其與derobert的有關轉換為遞歸的知識結合起來，並傳遞指向質數和似然的引用數組的指針。