Fatal编程技术网
  • java/
  • Java 递归方法中的堆栈溢出

Java 递归方法中的堆栈溢出

java arrays recursion

Java 递归方法中的堆栈溢出,java,arrays,recursion,stack-overflow,Java,Arrays,Recursion,Stack Overflow,我正在编写一个程序，允许用户在数组中输入一组整数，一旦输入零，这些数字的特征就会显示出来。我对一种方法有一个问题：findMaxOfLessThanFirst。当然，它会在数组中找到小于输入的第一个数字的最大数字。以下是完整的代码： import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; public class Assignment9 { public s

我正在编写一个程序，允许用户在数组中输入一组整数，一旦输入零，这些数字的特征就会显示出来。我对一种方法有一个问题：findMaxOfLessThanFirst。当然，它会在数组中找到小于输入的第一个数字的最大数字。以下是完整的代码：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Assignment9 {
    public static void main(String[] args) throws IOException {
        int index = 0;
        int[] numbers;
        numbers = new int[100];

        InputStreamReader inRead = new InputStreamReader(System.in);
        BufferedReader buffRead = new BufferedReader(inRead);
        String line = buffRead.readLine();

        try {
            while (!line.equals("0") && index < 100) {
                numbers[index] = Integer.parseInt(line);
                index++;
                line = buffRead.readLine();
            }
        } catch (IOException exception) {
            System.out.println("Array index out of bound");
        }
        int min = findMin(numbers, 0);
        int sumAtEven = computeSumAtEvenIndexes(numbers, 0, numbers.length - 1);
        int divByThree = countDivisibleBy3(numbers, 0, numbers.length - 1);
        int maxLessThanFirst = findMaxOfLessThanFirst(numbers, 1, numbers.length - 1, numbers[0]);
        System.out.println("The minimum number is " + min);
        System.out.println("The sum of numbers at even indexes is " + sumAtEven);
        System.out.println("The count of numbers that are divisible by 3 is " + divByThree);
        System.out.println(
                "The maximum number among numbers that are less than the first number is " + maxLessThanFirst);
    }

    public static int findMin(int[] numbers, int index) {
        if (index == numbers.length - 1) {
            return numbers[index];
        } else {
            return Math.min(numbers[index], findMin(numbers, index + 1));
        }
    }

    public static int computeSumAtEvenIndexes(int[] numbers, int startIndex, int endIndex) {
        if (startIndex == endIndex) {
            if (startIndex % 2 == 0) {
                return numbers[startIndex];
            } else
                return 0;
        } else {
            if (endIndex % 2 == 0) {
                return computeSumAtEvenIndexes(numbers, startIndex, endIndex - 1) + numbers[endIndex];
            } else {
                return computeSumAtEvenIndexes(numbers, startIndex, endIndex - 1);
            }
        }
    }

    public static int countDivisibleBy3(int[] numbers, int startIndex, int endIndex) {
        if (startIndex == endIndex) {
            if (numbers[startIndex] % 3 == 0) {
                return +2;
            } else {
                return 1;
            }
        } else {
            if (numbers[endIndex] == 0) {
                return countDivisibleBy3(numbers, startIndex, endIndex - 1);
            }
            if (numbers[endIndex] % 3 == 0) {
                return countDivisibleBy3(numbers, startIndex, endIndex - 1) + 1;
            } else {
                return countDivisibleBy3(numbers, startIndex, endIndex - 1);
            }
        }
    }

    private static int findMaxOfLessThanFirst(int[] numbers, int startIndex, int endIndex, int firstNumber) {
        if (startIndex == endIndex) {
            if (numbers[endIndex] <= firstNumber)
                return numbers[startIndex];
        }
        int max = findMaxOfLessThanFirst(numbers, startIndex, endIndex - 1, firstNumber);
        if (max >= numbers[endIndex] && max <= firstNumber) {
            return max;
        }
        return numbers[endIndex];
    }
}

导入java.io.BufferedReader；
导入java.io.IOException；
导入java.io.InputStreamReader；
公共课堂作业9{
公共静态void main（字符串[]args）引发IOException{
int指数=0；
int[]数字；
数字=新整数[100]；
InputStreamReader inRead=新的InputStreamReader（System.in）；
BufferedReader buffRead=新的BufferedReader（读取中）；
String line=buffRead.readLine（）；
试一试{
而（！line.equals（“0”）&&index<100）{
数字[索引]=整数.parseInt（行）；
索引++；
line=buffRead.readLine（）；
}
}捕获（IOException异常）{
System.out.println（“数组索引超出范围”）；
}
int min=findMin（数字，0）；
int sumAtEven=计算的UMATEVINDEX（数字，0，数字.length-1）；
int divByThree=countDivisibleBy3（数字，0，数字.length-1）；
int maxlesthanfirst=findMaxOfflessThanfirst（数字，1，numbers.length-1，数字[0]）；
System.out.println（“最小数量为”+min）；
System.out.println（“偶数索引处的数字之和为”+sumAtEven）；
System.out.println（“可被3整除的数字的计数为”+除以3）；
System.out.println(
“小于第一个数字的数字中的最大数字为”+maxLessThanFirst）；
}
公共静态int findMin（int[]数字，int索引）{
如果（索引==numbers.length-1）{
返回编号[索引]；
}否则{
返回Math.min（数字[index]，findMin（数字，索引+1））；
}
}
公共静态int computesumatevinendex（int[]数字、int startIndex、int endIndex）{
if（startIndex==endIndex）{
如果（起始索引%2==0）{
返回编号[startIndex]；
}否则
返回0；
}否则{
如果（endIndex%2==0）{
return computeSumateVenindex（数字、startIndex、endIndex-1）+数字[endIndex]；
}否则{
返回计算的UMATEVINDEX（数字、起始索引、结束索引-1）；
}
}
}
公共静态整型整型可数整型by3（整型[]数字，整型起始索引，整型结束索引）{
if（startIndex==endIndex）{
如果（数字[startIndex]%3==0）{
返回+2；
}否则{
返回1；
}
}否则{
如果（数字[endIndex]==0）{
返回countDivisibleBy3（数字、起始索引、结束索引-1）；
}
如果（数字[endIndex]%3==0）{
返回countDivisibleBy3（数字，起始索引，结束索引-1）+1；
}否则{
返回countDivisibleBy3（数字、起始索引、结束索引-1）；
}
}
}
私有静态int findMaxOfLessThanFirst（int[]数字，int startIndex，int endIndex，int firstNumber）{
if（startIndex==endIndex）{

if（numbers[endIndex]=numbers[endIndex]&max您需要做的就是删除第一个
if
中嵌套的
if
条件。这是多余的，因为
startIndex
和
endIndex
都是相同的。下面应该可以工作：


private static int findMaxOfLessThanFirst(int[] numbers, int startIndex, int endIndex, int firstNumber) {
    if (startIndex == endIndex) {
        return numbers[startIndex];
    }
    int max = findMaxOfLessThanFirst(numbers, startIndex, endIndex - 1, firstNumber);
    if (max >= numbers[endIndex] && max <= firstNumber) {
        return max;
    }
    return numbers[endIndex];
}



private static int findMaxOfLessThanFirst（int[]numbers，int startIndex，int endIndex，int firstNumber）{
if（startIndex==endIndex）{
返回编号[startIndex]；
}
int max=findMaxOfflessThanFirst（数字，开始索引，结束索引-1，第一个数字）；

如果（max>=numbers[endIndex]&&max您正在运行一个无限递归（通常是在递归程序中获得
StackOverflowerError
时的情况）。您尝试了以下代码来停止递归：


    if (startIndex == endIndex) {
        if (numbers[endIndex] <= firstNumber)
            return numbers[startIndex];
    }



if（startIndex==endIndex）{

如果（numbers[endIndex]firstNumber
，这不会停止递归，因此它会继续进行-而不是无限“仅”在你点击
StackOverflowerError
之前，你将丢失
else
分支。如果你有
if
，则必须有
else
，我将此作为编程规则。在某些情况下
else
可能没有用，在这种情况下，我将一些日志信息放入
else


 private static int findMaxOfLessThanFirst(int[] numbers, int startIndex, int endIndex, int firstNumber) {
    if (startIndex == endIndex) {
        if (numbers[endIndex] <= firstNumber)
            return numbers[startIndex];          
        else return Integer.MIN_VALUE;
    }
    int max = findMaxOfLessThanFirst(numbers, startIndex, endIndex - 1, firstNumber);
    if (max >= numbers[endIndex] && max<=firstNumber) {
        return max;
    }
    return numbers[endIndex];
}



private static int findMaxOfLessThanFirst（int[]numbers，int startIndex，int endIndex，int firstNumber）{
if（startIndex==endIndex）{

如果（numbers[endIndex]=numbers[endIndex]&&max这个问题以前有人问过，虽然没有完整的答案，但它似乎是一个家庭作业问题和“提问者”你没有给它足够的时间。只把代码放在你面临问题的地方，这样别人就可以容易地阅读。今天我想，有人问了完全相同的问题。在我决定发布之前，我试着想了很久。我的错。不知道有其他人问同样的问题。好的。这是有道理的。不过，现在，在一些测试c上如果该方法似乎无法正常工作。输入值为：-31，-31，-31，-34，-31，0，-31，-34，-34，-31。它返回最大值为0。当第一个数字不是负数时，该方法似乎可以正常工作。为简单起见，我尝试了输入-1，-4，0。在输入0后，您的程序不接受任何输入。它仍然检查所有数据但是，数组中有100个数字。因此递归方法会查看越来越短的子数组，直到startIndex和endIndex都为1。此时返回-4。由于-4不大于以下元素0，因此方法返回
numbers[endIndex]