使用递归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的有关转换为递归的知识结合起来，并传递指向质数和似然的引用数组的指针。