Question

我正在使用Java。

我需要实现一个递归函数来计算每两个值之间的差异，并返回大小为2 [MAXIMUM_DIFF, STARTINDEX]的数组。

对于以下数组：

arr = {1, 4, 60, -10, 2, 7, 56, -10}

递归方法返回大小为2的数组：[70,2]，因为最大差异为70 (60-(-10)=70)，索引60为2.

我有90％来自解决方案：

public static int[] getMax(int[] arr) {

    int [] retArr = new int[2];

    if(arr.length == 1)
        return retArr;
    else {
        return getMax(arr, retArr);
    }

}

public static int[] getMax(int[] arr, int[] retArr) {
    if(retArr[1] == arr.length - 1)
        return retArr;

    int currentMaxVal = arr[retArr[1]] - arr[retArr[1] + 1];

    if(currentMaxVal > retArr[0]) {
        retArr[0] = currentMaxVal;
    }

    retArr[1] = retArr[1] + 1;

    return getMax(arr, retArr);

}

但结果是[70,7]而不是[70,2]，因为这一行retArr[1] = retArr[1] + 1;

这是因为我不知道保存索引的位置，那么如何保存索引呢？

*我不确定getMax(int [] arr, int []retArr)的第二个参数可能会有所不同

我无法添加其他参数，可能更改getMax(int [] arr, int []retArr)的第二个参数，而我无法使用静态变量

Answer 1

if(currentMaxVal > retArr[0])
{
  retArr[0] = currentMaxVal;
}

retArr[1] = retArr[1] + 1;

应该是

if(currentMaxVal > retArr[0])
{
  retArr[0] = currentMaxVal;
  retArr[1] = currentIndex;
}

currentIndex应该是传递给函数的附加参数。（以及对当前索引的其他引用相应更新）

更新：

我认为这里的重点是要理解“分而治之”，将问题分解为一个较小的问题，然后进行最佳分类。像这样的东西（如果比普通情况更尴尬）

public static int[] getMax(int[] arr, int[] retArr) {
    // Return case
    if (retArr[1] >= arr.length - 1)
        return new int[] { Integer.MIN_VALUE, retArr[1] };

    // Save context
    int index = retArr[1];
    int value = arr[index] - arr[index + 1];

    // Call recursion
    retArr[1]++;
    int[] temp = getMax(arr, retArr);

    // Return best between current case and recursive case
    if (temp[0] > value)
        return temp;
    else
        return new int[] { value, index };
}

递归函数的每个调用（或堆栈）都是它自己的上下文。这意味着在它中声明的变量不会在递归调用中被覆盖。这个想法是你以递归的方式解决一个难题，直到你无法进一步分解为止。然后你通过一次一个地调整每个调用的结果来解决它，直到你得到你的最终答案。（这对于像斐波纳契序列这样不太重要的情况更好。）另请注意，在循环中完成的任何事情总是比递归更有效。

递归函数到数组中两个值之间的差异

1 个答案: