用递归区分偶数和奇数

Question

我有一个问题，我正在经历一段艰难的时间，发现如果有人能指出我正确的方向。

我写这需要一个int为它的参数递归方法（或多个），然后显示奇数（自上而下），则偶数的所有平方值的所有平方值（再次自上而下）

例如6将输出

25，9,1，36，16，4

我的方法将是有3种方法。一个int recursiveOdd(int num)将计算并输出以控制奇数的平方值。一个int recursiveEven(int num)将计算并输出以控制偶数的平方值。和一个方法void passToRecursive(int num)，只需要数字并调用其他两种方法。

我的问题是我如何处理第一种方法，找到最高的奇数，然后找到最高的偶数而不使用循环。

很明显，最大的数量是int从main通过。 我简直无法想象我将如何找到最高的奇怪的W/O循环。

Answer 1

如果给定的数字N，那么最高的偶数是通过取一半，截断，再乘以发现2：

(N/2) * 2 

最高奇数有点麻烦：减去1，找到最高甚至是，然后数加1：

((N-1)/2) * 2 + 1 

那向你两个数字（如需要截断/楼）。现在，对于递归：你需要你的基本情况（完成条件）和你的递归情况。

基本情况：if N <= 0，返回时没有打印任何东西。 递归：print N*N;重复值（N-2）。

顺便说一下，请注意递归例程是相同对于奇数和偶数情况：您只需要一个递归例程。从passTo到例程中调用它两次，每次使用您在开始时发现的奇数和偶数。

最后，请考虑更改名称passToRecursive。这有点误导，因为它本身不是一个递归例程;它只是一个处理程序。有人称它不在乎它有递归子程序。相反，给它一个名字来描述它的功能。

Answer 2

如果你是在正确的方向寻找poiner，则尝试转换成C++

function oddSquare(int value) { 
    if (value mod 2 == 0) value --; 
    if (value > 0) { /* Stop when we get too small */ 
    print value * value; 
    oddSquare(--value); /* Decrement to next lower value and recurse 
    } 
} 

Answer 3

我们初学者这应该互相帮助。:)

我可以建议一个基于在递归函数内使用静态变量的解决方案。

这是一个示范程序。

#include <iostream> 

void OddEvenSquares(unsigned int n) 
{ 
    static unsigned long long int even; 

    if (n != 0) 
    { 
     if (n % 2) 
     { 
      std::cout << static_cast<unsigned long long int>(n) * n << ' '; 
      OddEvenSquares(n - 1); 
     } 
     else 
     { 
      even += 2; 
      OddEvenSquares(n - 1); 
      std::cout << even * even << ' '; 
      even -= 2; 
     } 
    }   
} 

int main() 
{ 
    const unsigned int N = 10; 

    for (unsigned int i = 1; i <= N; i++) 
    { 
     OddEvenSquares(i); 
     std::cout << std::endl; 
    }   
}  

它的输出是

1 
1 4 
9 1 4 
9 1 16 4 
25 9 1 16 4 
25 9 1 36 16 4 
49 25 9 1 36 16 4 
49 25 9 1 64 36 16 4 
81 49 25 9 1 64 36 16 4 
81 49 25 9 1 100 64 36 16 4 

或者函数可以有默认参数第二个参数。

例如

#include <iostream> 

std::ostream & OddEvenSquares(unsigned int n, std::ostream &os = std::cout) 
{ 
    static unsigned long long int even; 

    if (n != 0) 
    {   
     if (n % 2) 
     { 
      std::cout << static_cast<unsigned long long int>(n) * n << ' '; 
      OddEvenSquares(n - 1, os); 
     } 
     else 
     { 
      even += 2; 
      OddEvenSquares(n - 1, os); 
      os << even * even << ' '; 
      even -= 2; 
     } 
    } 

    return os; 
} 

int main() 
{ 
    const unsigned int N = 10; 

    for (unsigned int i = 1; i <= N; i++) 
    { 
     OddEvenSquares(i) << std::endl; 
    }   
}  

程序输出将如上述所示的相同。

至于你的方法，当有奇数两个独立的递归函数和偶数则函数passToRecursive可以看看下面的方式

void passToRecursive(int num) 
{ 
    if (num > 0) 
    { 
     int odd, even; 

     if (num % 2) 
     { 
      odd = num; 
      even = odd - 1; 
     } 
     else 
     { 
      even = num; 
      odd = even - 1; 
     } 

     recursiveOdd(odd); 
     recursiveEven(even); 
    } 
} 

您可以将内部的if-else语句更改为有条件的经营者。例如

void passToRecursive(int num) 
{ 
    if (num > 0) 
    { 
     int odd, even; 

     num % 2 ? (odd = num, even = odd - 1) 
       : (even = num, odd = even - 1); 

     recursiveOdd(odd); 
     recursiveEven(even); 
    } 
} 

事实上，你甚至不需要定义两个递归函数，因为它们的物体可以是相同的。

所以功能passToRecursive可以像

void passToRecursive(int num) 
{ 
    if (num > 0) 
    { 
     int odd, even; 

     num % 2 ? (odd = num, even = odd - 1) 
       : (even = num, odd = even - 1); 

     recursiveSquares(odd); 
     recursiveSquares(even); 
    } 
} 

重视这一说法

std::cout << static_cast<unsigned long long int>(n) * n << ' '; 

两个整数的乘积可以比可以存储在int型或unsigned int值的最大值。因此，您需要使用一些较大的整数类型，例如long long int或unsigned long long int。

通常我的答案是最好的。:)