0

我写了以下代码

我的目标是获得最低值，doble[] absOfSub但它在行给出以下异常 compared= Double.compare(d2, d1);

Exception in thread "main" java.lang.StackOverflowError

为什么溢出以及如何修复它？

编辑

  public class TestThe {
static double[] absOfSub = new double[5];
    private static int index=0;

  private static int compare(int currentIdx, int minIdx) {
      if(index < absOfSub.length) {
         if(absOfSub[currentIdx] < absOfSub[minIdx]) {
             compare(currentIdx + 1, currentIdx);
         } else {
             compare(currentIdx + 1, minIdx);
         }
      }
  return minIdx;
  }

    public static void main(String[] args) {
    absOfSub[0]=1000;
    absOfSub[1]=810;
    absOfSub[2]=108;
    absOfSub[3]=130;
    absOfSub[4]=110;
double result;
   int inndex= compare(0,1);
      System.out.println(absOfSub[inndex]);
    
    }
}
4

5 回答 5

5

这个简单而优雅的解决方案怎么样？

static double min(double... ds) {
  double min = Double.POSITIVE_INFINITY;
  for (double d : ds) min = Math.min(min, d);
  return min;
}

public static void main(String[] args) {
  System.out.println(min(-5.2, 0, -10.1, 3));
}

递归解决方案（不推荐！）：

static double minRecur(double... ds) {
  return minRecur(ds, 0, Double.POSITIVE_INFINITY);
}
static double minRecur(double[] ds, int i, double runningMin) {
  return (i < 0 || i >= ds.length)? 
    runningMin : minRecur(ds, i + 1, Math.min(runningMin, ds[i]));
}
于 2012-04-25T08:09:03.340 回答
2

您不会更改index方法内部的值。所以这个递归方法调用根本不会停止。

于 2012-04-25T08:04:24.277 回答
2

您实际上并没有更改索引变量，因此递归永远不会结束。但这还有很多错误。

一种在数组中查找最小值的简单通用方法，无需使用递归：

int min = Integer.MAX_VALUE;
for( int i = 0; i < array.length; i++ ) {
    // Math.min returns the lower value of the two arguments given
    min = Math.min( min, array[i] );
}
return min;

这可以很容易地适应您的需求。

于 2012-04-25T08:10:21.300 回答
2

你永远不会操纵index变量的值。您看到人们应该尝试限制他们使用的静态变量数量的另一个原因。让我试着帮助你：

public class TestThe {
  private static double[] absOfSub = new double[5];
  private static void compare(int currentIdx, int minIdx) {
      if(currentIdx < absOfSub.length) {
         if(absOfSub[currentIdx] < absOfSub[minIdx]) {
             return compare(currentIdx + 1, currentIdx);
         } else {
             return compare(currentIdx + 1, minIdx);
         }
      } else {
         return minIdx;
      }
  } 

  public static void main(String[] args) {
      absOfSub[0] = 10;
      absOfSub[1] = 810;
      absOfSub[2] = 108;
      absOfSub[3] = 130;
      absOfSub[4] = 110;
      System.out.println("The minimum value is: " + absOfSub[compare(0, 0)]);
  }
}

编辑更多注释：

  • 始终将属性访问器指定为私有，当这是意图时
  • 总是格式化你的代码
  • 当您编写递归时，请确保您始终为每次后续调用更改某些内容，并且它可以让您更接近结束条件。
  • double原始类型本身定义了一个比较运算符，无需Double.compare在您的情况下使用。
于 2012-04-25T08:10:35.087 回答
0

每个例程中的索引都具有 0 或 1 或 2 作为值。

于 2012-04-25T08:06:17.100 回答