Question

我有一个问题，我很难搞清楚，我想我是否有人能指出我正确的方向。

我正在编写一个递归方法，它接受int的参数，然后显示奇数的所有平方值（自上而下），然后显示偶数的所有平方值（再次自上而下）

E.g 6将输出

25,9,1,36,16,4

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

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

显然，最大数量将是从int传递的main。我根本无法想到如何在循环中找到最高奇数。

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。

通常我的答案是最好的。：）

用递归来区分偶数和奇数

3 个答案: