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，则程序将失败。

检查数字是否为素数的天真算法是trial division algorithm。使用递归实现：

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查找素数的常用答案是Sieve of Erasthones。但首先，你需要弄清楚你是如何确定这个数字是否是半素数的。如果你愿意，你可以从1到7抓住琐碎的案例。在那之后，这是一个运行筛子和检查每个素数作为除数的问题。如果它是一个偶数除数并且商也在你的素数列表中，那么你就是金色的。如果它不在您的素数列表中（并且尚未通过筛子到达），请将其添加到可能性列表中，并在生成足够高的素数时检查它们。一旦找到两个素数，就会成功退出。如果达到你的数字除以最小的除数，则退出失败。

Catch是，我无法想出一种在递归中实现这一点并且不会损害性能的方法。也就是说，你可以将它与derobert关于转换为递归的内容结合起来，将指针传递给你的素数和可能性的参考数组。

使用递归c ++查找半素数

3 个答案: