Question

我试图使用递归找到数组的范围（最大 - 最小）。既然，只有一个返回值，我有点困惑如何解决这个问题。到目前为止我所做的是递归地找到最大值和最小值，然后在范围函数中使用它来查找范围。我想知道是否有可能以某种方式递归地在范围函数中做所有事情。

public static int max(int[] array, int N) {
    int maximum;

    if (N >= array.length) {
        maximum = Integer.MIN_VALUE;
    } else {
        maximum = max(array, N + 1);
        if (array[N] > maximum) {
            maximum = array[N];
        }
    }

    return maximum;
}

public static int min(int[] array, int N) {
    int minimum;

    if (N >= array.length) {
        minimum = Integer.MAX_VALUE;
    } else {
        minimum = min(array, N + 1);
        if (array[N] < minimum) {
            minimum = array[N];
        }
    }

    return minimum;
}   

public static int range(int [] array)
{
    int max1 = max(array , 0);
    System.out.println(max1);
    int min1 = min(array , 0);
    System.out.println(min1);
    int range = max1 - min1;

    return range;
}

Answer 1

如果递归确实是一个要求，而你只需要范围，那么应该这样做：

public static int range(int [] array, int index, int min, int max)
{
    if (index == array.length) {
        if (index == 0)
            return 0;
        else
            return max - min;
    }
    else {
        int value = array[index];
        return range(array, index + 1, Math.min(value, min), Math.max(value, max));
    }
}

public static int range(int [] array)
{
    return range(array, 0, Integer.MAX_VALUE, Integer.MIN_VALUE);
}

Answer 2

您的算法似乎太复杂了，无法实现您的目标。

目前尚不清楚是否需要使用递归。如果不是，那怎么样？

public int range (int[] array) {
    int min = Integer.MAX_VALUE;
    int max = Integer.MIN_VALUE;
    for (int elem : array) {
        if (elem < min) min = elem;
        if (elem > max) max = elem;
    }
    return (max - min);
}

在移动设备上，所以我无法测试任何代码，但它应该有效。

编辑：好的抱歉，重新阅读您的问题我看到您只想知道如何使用递归进行操作。也许你想在标题中明确这一点; - ）

Answer 3

你可以在方法中提供一个带有min（索引0）和max（索引1）的int []，并在同一个方法中完成所有操作。

public class Test {

@org.junit.Test
public void test() {

    int[] array = new int[] { -5,2,4,6,-10,44};
    int[] minmax = new int[ 2 ];
    minmax( array, minmax, 0 );

    assertEquals( "[-10, 44]", Arrays.toString( minmax ) );
}

public static void minmax(int[] array, int[] minmax, int N) {
    if (N >= array.length) {
        return;
    } else {
        minmax(array, minmax, N + 1);
        if (array[N] < minmax[0]) {
            minmax[0] = array[N];
        } 
        if (array[N] > minmax[1]) {
            minmax[1] = array[N];
        } 
    }
}

}

Answer 4

例如，您可以返回一个数组（0表示最小值，1表示最大值），这样就可以返回两个值。

更好的方法是将回调函数传递给您的方法，并在完成后调用它。

findMinMax(array, (min, max) -> { System.out.println(min + " " + max);});

private void findMinMax(int[] array, BiFunction<Integer, Integer, Void> callback) {
    //Do things
    callback.apply(min, max);
}

Answer 5

这个问题在递归方面没有任何改进，因为它是一个迭代问题 - 相反 - 由于堆栈大小的增加会导致性能问题，特别是对于大型数组。无论如何，java 7中的一个更经典的例子可以是以下，你可以使用一个最小的“Couple”类来存储最小/最大值

public class MaxMinRecurse {

    void evalMaxMinInInterval(Couple maxmin, int pos, int[] values) {
        if (pos >= values.length)
            return;
        int x = values[pos];
        if (x < maxmin.min) {
            maxmin.min = x;
        } else if (x > maxmin.max) {
            maxmin.max = x;
        }
        evalMaxMinInInterval(maxmin, pos + 1, values);
    }

    public static void main(String[] args) {
        MaxMinRecurse mmr = new MaxMinRecurse();
        int[] values = { 1, 5, 3, 4, 7, 3, 4, 13 };
        Couple result = mmr.new Couple();
        mmr.evalMaxMinInInterval(result, 0, values);
        System.out.println("Max: " + result.max + ", Min:" + result.min);
    }

    class Couple {
        int min = Integer.MAX_VALUE;
        int max = Integer.MIN_VALUE;
    }

}

数组中的最大减去最小值

5 个答案: