Question

你好，我正在学习Java，在完成了一些学习递归的任务之后，我正在给自己做一些练习来学习一些递归，但是现在我正在为之奋斗。

所以主要的问题是，当数组中的每个元素都是对象时，我不知道如何递归地对数组中的每个元素进行乘法运算（最后，无论对象是否存在，都没有区别）。因此，我给自己做的练习是：检查1/3是否在给定数组中。如果是，则将该数组中的所有内容乘以2/1。这是分数：

 private int numerator;      // Zaehler
 private int denominator;    // Nenner

        public Fraction ( int num, int denom )
        {
            if ( denom != 0 )
            {
                if ( denom < 0 )
                {
                    numerator = -num;
                    denominator = -denom;
                }
                else
                {
                    numerator = num;
                    denominator = denom;
                }
                reduce();
            }
            else
            {
                // error: division by zero
                throw new IllegalArgumentException();
            }
        }

        public Fraction()
        {
            numerator = 0;
            denominator = 1;
        }

        public Fraction( int num )
        {
            numerator = num;
            denominator = 1;
        }

所以我通过使用for循环来完成它：

public static Fraction[] mulWithFor(Fraction[] arr)
        {
            for (int i = 0; i<arr.length; i++)
            {
                arr[i] = arr[i].multiply(new Fraction(2,1));
            }
            return arr;
        }

但这不是我的主要目标，我想递归地做到这一点，这就是我的方法：

public static Fraction[] mulAus(Fraction[] arr, int i)
        {
            if (i>= 0 && i<arr.length)
            {
                rekurMul(arr,i);
                //return mulAus(rekurMul(arr,i-1));
            }
            return arr;
        }

        public static Fraction rekurMul(Fraction[] arr, int i)
        {
            if (i>= 0 && i<arr.length)
            {
                return arr[i].multiply(new Fraction(2,1));
                return arr[i].multiply(new Fraction(2, 1)); // Does Not Work!!!
            }
            throw new IndexOutOfBoundsException();
        }

也许有人可以帮助我！谢谢您的关注。

好，感谢@ChaïSarfati和其他尝试帮助我的人。我现在知道如何在数组中乘以递归运算！我使用了@ChaïSarfati的方法，但是为他的“ oneThirdIsPresent”写了另一种方法，这也是一种递归方法：所以现在我的工作代码如下：

 public static Fraction[] mulAus(Fraction[] arr)
        {
            if(contains(arr,arr.length-1,new Fraction(1,3)))
            {
                rekurMul(arr,0);
                return arr;
            }
            throw new IllegalArgumentException("1/3 does not exist in the Input-Array");
        }

        public static void rekurMul(Fraction[] arr, int i)
        {
            if(i == arr.length)
            {
                return ;
            }
            arr[i] = arr[i].multiply(new Fraction(2,1));
            rekurMul(arr,i+1);
        }

检查给定数组中是否存在1/3的方法。

public static boolean contains(Fraction[] arr, int i, Fraction x)
        {
            if (i>= 0 && i < arr.length)
            {
                if (arr[i].equals(x))
                { return true;}
                else
                { return contains(arr, i-1,x); }
            }
            return false;
        }

我希望其他人可以从代码中学习。。也许有更好的解决方案，但是我只是开始编程，所以暂时不了解它们。再见

Answer 1

假设您有一个multiplyBy(Fraction f)类可以在您的Fraction类中正常工作的方法。而且，迭代地进行迭代会更好（更具可读性，节省更多的时间和空间复杂性）。为了这个例子，我会这样：

首先定义：

private static boolean oneThirdIsPresent(Fraction[] arr){
    for (int i = 0; i < arr.length; i++) {
        if(arr[i].numerator == 1 && arr[i].denominator == 3) {
            return true;
        }
    }
    return false;
}

private static void recursivelyMultBy2(Fraction[] arr, int index){
    if(index == arr.length){
        return;
    }
    arr[index] = arr[index].multiplyBy(new Fraction(2));
    recursivelyMultBy2(arr, index+1);
}

为了最终解决：

public static void multBy2IfOneThirdIsPresent(Fraction[] arr){
    if(oneThirdIsPresent(arr)){
        recursivelyMultBy2(arr, 0);
    }else{
        return;
    }
}

Answer 2

这是递归乘法部分的快速示例：

17:15:19 WARN [main] org.hibernate.orm.cache: HHH90001006: Missing cache[user] was created on-the-fly. The created cache will use a provider-specific default configuration: make sure you defined one. You can disable this warning by setting 'hibernate.javax.cache.missing_cache_strategy' to 'create'.

修改的分数类（底部的乘法代码）：

public static void main(String[] args)
{
    Fraction[] fractions = new Fraction[] {new Fraction(1,2), new Fraction(2,3), new Fraction(3,1)};

    System.out.println("Fractions:");
    for(Fraction f: fractions)
    {
        System.out.println(f);
    }

    System.out.println("Multiplying array by 2...");
    Fraction.mulAus(fractions, new Fraction(2, 1));
    for(Fraction f: fractions)
    {
        System.out.println(f);
    }
}

输出：

用Java递归地将数组中的对象与另一个对象相乘

2 个答案: