在 java 中找到數組中的最大雙精度數

Question

這是代碼，我一直沒有從 getMax 方法中得到正確的 output。 我用一個ArrayList的int值之和填充一個數組，然后檢查其中一個是最小的和最大的，最后輸出它們並去掉小數位，這可能會導致錯誤？ 代碼可能不好，我是菜鳥：

public static void miniMaxSum(ArrayList<Integer> arr) {
    
    double[] acc = new double[arr.size()]; 
    for (int i=0; i<arr.size(); i++){
        for (int j=0; j<arr.size(); j++){
            acc[i] += arr.get(j);
            }
        acc[i] -= arr.get(i);
        }
             
    //double min = acc[arr.size()-1];
    //double max = acc[0];
    System.out.printf("%.0f", getMin(acc));
    System.out.print(" ");
    System.out.printf("%.0f", getMax(acc));     
    }             

public static double getMin(double[] acc){
    double min = 0;
    for (int j=0; j<acc.length; j++){
        for (int i=0; i<acc.length; i++){
            if (acc[i] > acc[j]){
                min = acc[j];
            } else {
                min = acc[i];
            }
            
        }
    }     
    return min; 
}
public static double getMax(double[] acc){
    double max = 0;
    for (int j=0; j<acc.length; j++){
        for (int i=0; i<acc.length; i++){
            if (acc[i] > acc[j]){
                max = acc[i];
                System.out.println(max);
            } 
            else {
                max = acc[j];
            }
            
        }
    }     
    return max; 
}
       

Answer 1

自己檢查的方法

public static double findMax(double[] data) {
    double max = Double.MIN_VALUE;
    for (double val : data) {
        if (val > max) {
            max = val;
        }
    }
    
    return max;
}

使用數學實用程序

public static double findMax2(double[] data) {
    double max = Double.MIN_VALUE;
    for (double val : data) {
        max = Math.max(val, max);
    }
    
    return max;
}

使用流

public static double findMax3(double[] data) {
    return Arrays.stream(data).max().getAsDouble();
}

自己檢查

public static double findMin(double[] data) {
    double min = Double.MAX_VALUE;
    for (double val : data) {
        if (val < min) {
            min = val;
        }
    }
    
    return min;
}

使用數學實用程序

public static double findMin2(double[] data) {
    double min = Double.MAX_VALUE;
    for (double val : data) {
        min = Math.min(val, min);
    }
    
    return min;
}

使用流

public static double findMin3(double[] data) {
    return Arrays.stream(data).min().getAsDouble();
}

Answer 2

你可以在一個循環中做任何你想做的事情。 首先計算每個值的總和，然后檢查該總和是否為新的最大值和/或最小值。 如果這些選項中的任何一個為真，則更新相應的最大值或最小值。

import java.util.*;

public class Application {

    public static void main(String[] args) {
        var test = new double[]{10d, 4.43d, 5.3d, -6.8d, 7.1d, 8.7d, 8.1d, 234d, -3.9d, -455.3d};
        minMaxSum(test);
    }

    public static void minMaxSum(double[] arr) {
        double acc = 0;
        // initialize the minimal value with the maximal value
        double min = Double.MAX_VALUE;
        // initialize the biggest value with the smallest possible value
        double max = Double.MIN_VALUE;
        var sum = new double[arr.length];
        // a single for loop
        for (int i = 0; i < arr.length; i++) {
            var cur = arr[i];
            // sum up adding the current value
            acc += cur;
            // save the current value in new array so we can verify the result (not actually required for the algorithm)
            sum[i] = acc;
            // if something is smaller than what we've already encountered => set new smallest value
            if(acc < min) min = acc;
            // if something is bigger than what we've already encountered => set new biggest value
            if(acc < max) max = acc;
        }
        System.out.printf("""
                Original:   %s
                Prefix-sum: %s
                Min: %s
                Max: %s
                """, Arrays.toString(arr), Arrays.toString(sum), min, max);
    }

}

預計 output：

Original:   [10.0, 4.43, 5.3, -6.8, 7.1, 8.7, 8.1, 234.0, -3.9, -455.3]
Prefix-sum: [10.0, 14.43, 19.73, 12.93, 20.03, 28.73, 36.83, 270.83, 266.93, -188.37]
Min: -188.37
Max: 270.83

由於許多人建議將排序作為一種可行的方法，因此這里有一些關於排序的評論。 首先，是的，它會給你一個正確的結果，但要付出代價，那就是速度，而且它只是一個不必要的復雜解決方案。

基於比較且沒有任何先決條件的排序不能比O(n log n)更快地完成。 很明顯，上面的解決方案需要O(n)時間，因此復雜度更快 class。 此外，上述解決方案中的常量（在大 O 表示法中被忽略）非常小，因此即使滿足一些先決條件，您也可以使用特殊的排序算法，如Map 排序（或類似算法），它在O(n) （再次：在某些條件下）上述解決方案仍然會更快，更不用說，更簡單了。 所以不要讓你的生活變得比它需要的更艱難。

Answer 3

您不需要對 getMax 或 getMin 函數使用嵌套循環。

    public static double getMax(double[] acc){
        double max = Double.MIN_VALUE;
        for (double value : acc) {
            if( value > max) max = value;
        }
        return max;
    }

如果你想對列表進行排序：

    public static void miniMaxSum(ArrayList<Integer> arr) {
        if(arr.size() > 0) {
            Collections.sort(arr);
            System.out.println(arr.get(0));
            System.out.println(arr.get(arr.size() - 1));
        }
    }