Question

我正在尝试编写一个简单的max和min方法，正如我写的那样，我不能帮助它感觉它不应该是这么复杂......。我可能错了吗？我的最大代码就是这样，原谅我糟糕的伪代码：

用10个随机数填充数组。创建一个初始化为0的max变量，因为0是最低的最大值。将每个元素与最大值进行比较如果元素大于max，则将max的值替换为有问题的元素

我不喜欢我必须将max初始化为0的事实，我觉得可能有更好的方法呢？

除了I，我的min代码工作方式类似：比较我的min低于数组元素。如果元素较低，则替换为min。

我真的不喜欢这个是我必须将我的min初始化为最大随机数，在本例中为50。

我的问题是：有一个更好的方法吗？有没有更有效的方法来编写这段代码？

import java.util.Random;

public class Main {

public static void main(String[] args) {

    //Declare min and max
    int max=0;
    int min;
    //Array of 10 spaces
    int[] ar=new int[10];
    //fill an array with random numbers between 0 and 50

    for(int i=0;i<10;i++)
    {
        ar[i]=new Random().nextInt(50);
    }

    //Test max algorithm
    //loop trough elements in array
    for(int i=0;i<10;i++)
    {
        //max is set to 0, there should always be a maximum of 0
        //If there isnt 0 will be the maximum

        //If element is greater then max
        //replace max with that element
        if(ar[i]>max)
        {
            max=ar[i];
        }
    }
    System.out.println("The max is "+ max);

    //Test min
    //Initialising min to maximum Random number possible?
    min=50;
    for(int i=0;i<10;i++)
    {
        if(ar[i]<min){
            min=ar[i];
        }
    }
    System.out.println("The min is "+min);


}

}

Answer 1

你总是可以抓住数组的第一个元素（即numbers[0]）作为初始值，然后从第二个元素开始循环。

int[] numbers = new int[10];
int max, min;
...
min = max = numbers[0];
for(int i = 1; i < numbers.length; ++i) {
    min = Math.min(min, numbers[i]);
    max = Math.max(max, numbers[i]);
}

Answer 2

好的，虽然其他人已经发布了答案，但我已经花时间将代码编辑成我认为更有用的代码。

制作静态方法。那些可以重复使用。
使用省略号（...），因为您可以在代码中调用数组参数上的方法，也可以使用min(5,3,8,4,1)的可变数量的参数调用方法。
使用数据类型提供的最小/最大可能数字进行初始化
要检查您的代码是否有效，您必须先打印出数组中的项目，因为当您不知道其中包含的内容时，无法判断结果是否正确。
将您的代码基于标准库中的现有方法，因为已知这些方法经过全面测试并且工作效率很高（我知道，min / max看起来像一个非常简单的例子）。
除非您真的能证明代码中存在性能问题，否则我不会过分担心性能问题。优先级应该更像第一正确性，第二可读性/可维护性，第三性能。

其他人已经提到了大部分内容，但无论如何，这是代码：

import java.util.Random;

public class MinMax {

    public static int min(int... args) {
        int m = Integer.MAX_VALUE;
        for (int a : args) {
            m = Math.min(m, a);
        }
        return m;
    }

    public static int max(int... args) {
        int m = Integer.MIN_VALUE;
        for (int a : args) {
            m = Math.max(m, a);
        }
        return m;
    }

    public static void main(String[] args) {

        // fill an array with random numbers between 0 and 50
        int[] ar = new int[10];
        for (int i = 0; i < 10; i++)
        {
            ar[i] = new Random().nextInt(50);
            System.out.println(ar[i]);
        }

        int maxValue = max(ar);
        int minValue = min(ar);

        System.out.println("The max is " + maxValue);
        System.out.println("The min is " + minValue);
    }
}

Answer 3

几点提示：

使用第一个元素初始化min并从第二个元素开始：
```
int min = ar[0];
for(int i=1;i<10;i++)
```
...或者从：
开始
```
int min = Integer.MAX_VALUE;
```
如果您希望阵列可以为空，则此方法更好。
使用Math.min来避免显式条件（有些人可能会说它的速度较慢）：
```
for(int i=0;i<10;i++)
{
   min = Math.min(min, ar[i]);
}
```

Answer 4

将max初始化为0＆amp;当数字改变时，min到50将不起作用。更合适的方式是：
1.将它们初始化为数组的第一个元素 2.使用length代替常量。

max = ar[0];  
    for(i=0;i<ar.length; i++)  
    {  
            if(ar[i]>max)  
            {  
                max=ar[i];  
            }  
    }

同样的分钟：

min = ar[0];
for(i=0;i<ar.length; i++)
{
        if(ar[i]<min)
        {
            min=ar[i];
        }
}

Answer 5

public static void main(String[] args) {
     int[] myArray = {9, 7,9, -40, -10, 40};
    //int[] myArray = {};
    //int[] myArray = {4};
    System.out.println("Difference between max and min = "
            + findDifference(myArray));
}

// Find difference between Max and Min values for a given array
public static int findDifference(int[] arr) {

    if (arr.length == 0) {
        // Log
        System.out.println("Input Array is empty");

        return Integer.MIN_VALUE;
    }

    int min = arr[0];
    int max = arr[0];

    for (int i = 1; i < arr.length; i++) {
        if (arr[i] < min)
            min = arr[i];
        else if (arr[i] > max)
            max = arr[i];
        // Just to check if logic works fine
        System.out.println("Min=" + min + " Max=" + max);
    }

    return max - min;

}

Answer 6

import java.io.*;

public class MultiDimensionalArrayIO {

public static void main(String[] args)throws IOException {
BufferedReader c= new BufferedReader (new InputStreamReader (System.in) );

System.out.print ( "Enter Number Column : " );
int column = Integer.parseInt(c.readLine());
System.out.print ( "Enter Number Row : " );
int row = Integer.parseInt(c.readLine());

int array [][] = new int [column][row];
int max = array [0][0];
int min = array [0][0];
int sum= 0;
for ( int i=0 ; i < array.length; i++){   
for (int j=0 ; j<array[i].length; j++){
    System.out.print("Enter Array Values ["+i+"]["+j+"]: " );
    array[i][j]= Integer.parseInt (c.readLine()); 

        min = Math.min(min , array[i][j]);
        max = Math.max(max , array[i][j]);
        sum += array[i][j];
}    
}

    System.out.println("The Min Number :"+ min);
    System.out.println("The Max Number :"+ max+ " total is "+ sum);

}
}

Answer 7

根据您是否需要同一方法中的max和min-functions，还必须考虑返回类型。

到目前为止，大多数建议都将两者分开，这意味着返回int是可以的。但是，如果将max和min函数放入findLargestDifference方法中，则必须返回长视图，因为int数组中任何给定数字之间的最大差异可以是2 int的大小。你也不必两次遍历int数组。

此外，我建议为角点和边缘情况编写单元测试，而不是在主方法中进行打印。它有助于在实现它时尽早测试您的逻辑，从而使代码更清晰。

请参阅下面的示例代码。

public class LargestDifference {

public static long find(int[] numbers) {
    if (numbers == null || numbers.length == 0) {
        throw new IllegalArgumentException("Input cannot be null or empty.");
    }else {
        long currentMax = numbers[0];
        long currentMin = numbers[0];

        for (int i=0; i < numbers.length; i++) {
            if (currentMin > numbers[i]) {
                currentMin = numbers[i];
            }else if (currentMax < numbers[i]) {
                currentMax = numbers[i];
            }
        }
        return currentMax - currentMin;
    }
}

使用Java中的数组更好的最小和最大算法

7 个答案: