这是我到目前为止所做的，但我对如何跟踪索引感到困惑。我会改变方法的参数，但我不允许。 我只能用一个循环来制作另一个数组。这些是限制。
public class RecursiveFinder {
static int checkedIndex = 0;
static int largest = 0;
public static int largestElement(int[] start){
int length = start.length;
if(start[length-1] > largest){
largest = start[length-1];
int[] newArray = Arrays.copyOf(start, length-1);
largestElement(newArray);
}
else{
return largest;
}
}
/**
* @param args
*/
public static void main(String[] args) {
int[] array1 = {0,3,3643,25,252,25232,3534,25,25235,2523,2426548,765836,7475,35,547,636,367,364,355,2,5,5,5,535};
System.out.println(largestElement(array1));
int[] array2 = {1,2,3,4,5,6,7,8,9};
System.out.println(largestElement(array2));
}
}
答案 0 :(得分：2)
递归方法不需要保留最大值。
2参数方法
开始致电：
largestElement(array, array.length-1)
以下是方法：
public static int largestElement(int[] start, int index) {
if (index>0) {
return Math.max(start[index], largestElement(start, index-1))
} else {
return start[0];
}
}
方法的第3行是最难理解的。它返回两个元素之一，即当前索引和剩余元素之一的大部分，以递归方式检查。
条件if (index>0)类似于while循环。只要索引保持为正（到达数组中的元素），就会调用该函数。
1参数方法
这个有点棘手，因为你必须传递比前一次迭代更小的数组。
public static int largestElement(int[] start) {
if (start.length == 1) {
return start[0];
}
int max = largestElement(Arrays.copyOfRange(start, 1, start.length));
return start[0] > max ? start[0] : max;
}
我希望你这样做是为了研究目的，实际上没有人需要用Java做这件事。
答案 1 :(得分：0)
您不需要在方法之外保留largest变量 - 这通常不是递归的好习惯，它应该返回结果的所有上下文。
当你考虑递归时，试着考虑一个简单的基本情况，其中答案是显而易见的，然后，对于所有其他情况，如何将其分解为更简单的情况。
所以在pseduo-code中你的算法应该是这样的：
func largest(int[] array)
if array has 1 element
return that element
else
return the larger of the first element and the result of calling largest(remaining elements)
您可以将Math.max用于更大的＆＃39;计算。
很遗憾，您无法更改参数，因为如果您可以将索引传递给开头或使用列表和子列表，则会更容易。但是你的复制方法应该可以正常工作（假设效率不是问题）。
上述算法的替代方法是将空数组作为基本情况。这样做的好处是可以处理空数组（通过返回Integer.MIN_VALUE）：
int largest(int[] array) {
return array.length == 0
? Integer.MIN_VALUE
: Math.max(array[0], largest(Arrays.copyOfRange(array, 1, array.length)));
}
答案 2 :(得分：0)
尝试上层阶级，保留主要方法是正确的。
public class dammm {
public static int largestElement(int[] start){
int largest = start[0];
for(int i = 0; i<start.length; i++) {
if(start[i] > largest){
largest = start[i];
}
}return largest;
}
答案 3 :(得分：0)
对于这个问题，你真的需要考虑使用基本情况。看看你需要处理的一些简单案例：
从上面我们可以了解问题的结构：
if array.length == 1 then
return array[0]
else
return the maximum of the values
在上面，如果我们只有一个元素，那么它就是列表中的最大值。如果我们有两个值，那么我们必须找到这些值的最大值。从这里，我们可以使用这样的想法：如果我们有三个值，我们可以找到它们中的两个的最大值，然后将最大值与第三个值进行比较。将其扩展为伪代码，我们可以得到类似的东西：
if array.length == 1 then
return array[0]
else
new array = array without the first element (e.g. {1, 2, 3} => {2, 3})
return maximum(array[0], largestElement(new array))
为了更好地解释上述内容，可以将执行视为链（{1,2,3}的示例）。
然后上面会回滚我们得到的'树'结构：
maximum (1, maximum(2, (return 3)))
获得最大值后，您可以使用上述示例原则通过单独的方法查找索引：
indexOf(array, maximum)
if array[0] == maximum then
return 0
else if array.length == 1 then
return -1
else
new array = array without the first element (e.g. {1, 2, 3} => {2, 3})
result = indexOf(new array, maximum)
return (result == -1) ? result : result + 1
为了进一步研究，我会从Racket语言中读到this。本质上，它显示了纯粹来自pairs的数组的概念，以及如何使用递归对其进行迭代。
如果您有兴趣，Racket是理解递归的非常好的资源。您可以在Racket上查看滑铁卢大学tutorial。它可以通过简单易懂的方式为您提供递归的简要介绍，并向您介绍一些示例，以便更好地理解它。
答案 4 :(得分：0)
如果你的目标是通过使用递归来实现这一目标，那么这就是你需要的代码。它不是最有效的，它不是处理问题的最佳方式，但它可能是你需要的。
public static int largestElement(int[] start){
int length = start.length;
if (start.lenght == 1){
return start[0];
} else {
int x = largestElement(Arrays.copyOf(start, length-1))
if (x > start[length-1]){
return x;
} else {
return start[length-1];
}
}
}
想象一下，你有一组数字，你只需要将一个数字与其余数字进行比较。
例如，假设 {1,8,5} ，我们只需检查 5 是否大于 {1,8的最大值} 即可。同样，您必须检查 8 是否大于 {1} 的最大值。在下一次迭代中，当集合中有一个值时，您知道该值是集合中的较大值。
因此，您将返回上一级别并检查返回值（ 1 ）是否大于 8 。结果（ 8 ）将返回到上一级别，并针对 5 进行检查。结论是 8 是更大的值
答案 5 :(得分：0)
一个参数，没有复制。棘手的是，我们需要将一个较小的数组传递给同一个方法。因此需要一个全局变量。
// Number of elements checked so far.
private static int current = -1;
// returns the largest element.
// current should be -1 when user calls this method.
public static int largestElement(int[] array) {
if (array.length > 0) {
boolean resetCurrent = false;
if (current == -1) {
// Initialization
current = 0;
resetCurrent = true;
} else if (current >= array.length - 1) {
// Base case
return array[array.length - 1];
}
try {
int i = current++;
return Math.max(array[i], largestElement(array));
} finally {
if (resetCurrent) {
current = -1;
}
}
}
throw new IllegalArgumentException("Input array is empty.");
}
如果您可以创建另一种方法，那么一切都会简单得多。
private static int recursiveFindLargest(int [] array, int i) {
if (i > 0) {
return Math.max(array[i], recursiveFindLargest(array, i-1));
} else {
return array[0];
}
}
public static int largestElement(int [] array) {
// For empty array, we cannot return a value to indicate this situation,
//all integer values are possible for non-empty arrays.
if (array.length == 0) throw new IllegalArgumentException();
return recursiveFindLargest(array, array.length - 1);
}
答案 6 :(得分：0)
您可以通过比较数组中的两个数字（[n]和[n + 1]），然后将较大的数组放在较小的数组中，来使用递归修改数组。因此，通过增加n，可以比较所有元素。因此，数组的最后一个元素是最大的。
public static int findLargest( int[] nums, int n ) {
if ( nums[n] > nums[n+1] ) {
nums[ n + 1 ] = nums[n];
}
else if ( n == nums.length - 2 ) { //if last element is bigger than previous one
return nums[nums.length - 1];
}
if( n == nums.length - 2 ){ return nums[n]; }
return findLargest( nums, n + 1 );
}
答案 7 :(得分：0)
这是带有一个方法参数的代码的有效示例
public int max(int[] list) {
if (list.length == 2) return Math.max(list[0], list[1]);
int max = max(Arrays.copyOfRange(list, 1, list.length));
return list[0] < max ? max : list[0];
}