Java 在数组中查找最小值和最大值的有效方法

我想找出整数数组中的最小值和最大值

以下哪种方法更有效

对数组排序，然后查看开始和结束以获得最小值和最大值

使用

Arrays.asList（）

将数组转换为列表，然后使用

Collections.min（）

方法

我想使用的代码如下所示：

// Find missing number from an array of consecutive numbers arranged randomly
import java.util.Arrays;

public class MissingNumber {

    public static void main(String[] args) {

        int[] consecutiveRandomNos = { 3, 6, 5 };

        System.out.println(addNumbers(consecutiveRandomNos));
        System.out.println("The missing number is "
                        + (returnSum(consecutiveRandomNos) - addNumbers(consecutiveRandomNos)));
    }

    public static int addNumbers(int... numbers) {
        int result = 0;

        for (int number : numbers) {
            result += number;
        }

        return result;
    }

    public static int returnSum(int... nos) {

        Arrays.sort(nos);

        int max = nos[nos.length - 1];

        int min = nos[0];

        int total = 0;

        for (int i = min; i <= max; i++) {
            total += i;
        }

        return total;
    }
}

//从随机排列的连续数字数组中查找缺少的数字
导入java.util.array；
公共类丢失号{
公共静态void main（字符串[]args）{
int[]连续的ANDOMNOS={3,6,5}；
System.out.println（addNumbers（concertiverandomnos））；
System.out.println（“缺少的号码是”
+（returnSum（consutiverandomnos）-addNumbers（consutiverandomnos））；
}
公共静态int addNumbers（int…numbers）{
int结果=0；
用于（整数：数字）{
结果+=数字；
}
返回结果；
}
公共静态整数返回和（整数…个）{
数组。排序（个）；
int max=个数[个数长度-1]；
int min=数量[0]；
int-total=0；
对于（int i=min；i源代码：

585     public static <T extends Object & Comparable<? super T>> T min(Collection<? extends T> coll) {
586         Iterator<? extends T> i = coll.iterator();
587         T candidate = i.next();
588 
589         while (i.hasNext()) {
590             T next = i.next();
591             if (next.compareTo(candidate) < 0)
592                 candidate = next;
593         }
594         return candidate;
595     }

585公共静态排序成本O（NlogN），通过数组查找最小和最大成本O（N）。
无需转换为列表，只需对数组进行排列。
排序最多为O（Nlog（N））。
int max = Integer.MIN_VALUE;
int min = Integer.MAX_VALUE;
for(int i=0; i<array.length; i++)
{
    if(array[i] < min)
       min = array[i]
    if(array[i] > max)
       max = array[i]
}

只要迭代数组，就可以在O（n）中找到极小值和极大值

int max = Integer.MIN_VALUE;
int min = Integer.MAX_VALUE;
for(int i=0; i<array.length; i++)
{
    if(array[i] < min)
       min = array[i]
    if(array[i] > max)
       max = array[i]
}

int max=Integer.MIN\u值；
int min=整数最大值；
for（int i=0；i）可以在O（1）中帮助您。事实上，您可以使用单个for循环解决整个问题：

int max = Integer.MIN_VALUE;
int min = Integer.MAX_VALUE;
int sum = 0;
for(int i=0; i<array.length; i++)
{
    if(array[i] < min)
       min = array[i];
    if(array[i] > max)
       max = array[i];
    sum += array[i];
}

return (max - min + 1)(max + min)/2 - sum;

int max=Integer.MIN\u值；
int min=整数最大值；
整数和=0；
对于（int i=0；i max）
max=数组[i]；
总和+=数组[i]；
}
返回（最大-最小+1）（最大+最小）/2-和；
先写一些代码可能是第2点：谢谢你的快速回复。我在想哪种方式更好。我应该先发布代码。“如果你的排序算法是O（n）”也许不是，或者D@Trinimon视情况而定，OP可能是Chuck Norris。@Trinimon通常情况下，它不能具有这种复杂性，但取决于对数据的约束，它可以。例如，如果要在[0；100]中对数字数组进行排序，可以在O（n）中进行排序@Arnauddenoylle这是最好的情况。。但请注意，即使数据已排序，也有一些算法不能有O（n）。@Arnaud denoylle:我知道，有些算法对于已排序的列表只需要O（n）。但是，我假设分布相等，因为在这方面没有特别说明。只有Chuck Norris需要始终有O（n）：D（p.s.检查）注意，这与其他答案相同，但在一个过程中同时找到max和min。stackoverflow的地狱人速度很快！集合内的迭代#min基本上做了相同的事情（使用迭代器），因此这些答案基本上是同样有效的。结果表明，3个答案基本上是在30秒内提交的（我没有看到它们），因此它们可能看起来重复。如果可以保存一个评估，而不是使用两个ifs，则使用一个else。您也不必担心边缘大小写
数组[I]==max
因为效果是一样的。它很简单，但可以加上upMmm，如果你是这个意思，我可以使用“else-if”。我不能完全删除第二个if，因为我看到的大多数新项可能都是