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

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

下面是递归乘法部分的简单示例：

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);
    }
}

Modified Fraction Class（乘法代码在底部）：

public class Fraction
{

        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();
            }
        }

        private void reduce()
        {
            // ... 
        }

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

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

        public String toString()
        {
            return numerator + " / " + denominator;
        }

        public void MultiplyBy(Fraction F)
        {
            if (F != null)
            {
                numerator = numerator * F.numerator;
                denominator = denominator * F.denominator;
                reduce();
            }
        }

        public static void mulAus(Fraction[] arr, Fraction F)
        {
            if(arr != null && F != null)
            {
                rekurMul(arr, 0, F);
            }
        }

        private static void rekurMul(Fraction[] arr, int i, Fraction F)
        {
            arr[i].MultiplyBy(F);
            if (i < (arr.length - 1))
            {
                rekurMul(arr, ++i, F);
            }
        }

}

输出：