は、二重[]

Question

の最小値を取得する私は私の目的はdoble[] absOfSubのlowst値を取得することですが、それはcompared= Double.compare(d2, d1);

Exception in thread "main" java.lang.StackOverflowError 

なぜオーバーフローラインで次の例外 を与える

次のコードを書きましたそれを修正する方法は？あなたのメソッドの内部 indexの値を変更しないでください

EDIT

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

。したがって、この再帰的メソッド呼び出しはまったく停止しません。

Answer 3

各ルーチンのインデックスは、値として0または1または2のいずれかを持っています。

Answer 4

あなたが実際にインデックス変数を変更しないので、再帰が終了することはありません。しかし、これにはもっと間違ったことがあります。

再帰を使用せずに、配列内の最小限の値を見つけるための簡単な一般的な方法は：

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 5

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

  EDITあなたが再帰を書いているときは、結果的に起こるすべての呼び出しに対して常に何かを変更し、終了条件に近づけるようにしてください。

• doubleプリミティブ型自体が比較演算子を定義しているため、Double.compareを使用する必要はありません。