修改

Question

我写了以下代码

我的目标是获得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]);

    }
}

Answer 1

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

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]));
}

Answer 2

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

Answer 3

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

一种简单的通用方法，可以在不使用递归的情况下查找数组中的最小值：

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;

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

Answer 4

您永远不会操纵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。

Answer 5

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

得到double []的最低值

修改

5 个答案: