Question

我想知道，编译器的哪种方式会更快。使用sort或循环方法显示最小值和最大值。对于编译器或程序员来说，哪种方法更快？

我将循环方法作为注释包含在内。

import java.util.Scanner;
import java.util.Arrays;

public class Day3 
{
    public static void main(String[] args) 
    {
        Scanner scan = new Scanner(System.in);
        System.out.println("Maximum and minimum value array");
        System.out.println("--------------------------------\n");

        //variable declaration
        int amount;
        int[] integerArray;

        //set amount
        System.out.print("Enter the amount of numbers to sort: ");
        amount = scan.nextInt();
        integerArray = new int[amount];

        //input loop
        System.out.print("Enter numbers: ");
        for(int i = 0; i < amount; i++)
        {
            integerArray[i] = scan.nextInt();
        }

        System.out.print("\nHere is your array: " + Arrays.toString(integerArray) + "\n");

        Arrays.sort(integerArray);
        System.out.println("Min value = " + integerArray[0]);
        System.out.println("Max value = " + integerArray[integerArray.length - 1]);
        System.out.println("Median value = " + integerArray[(integerArray.length -1) / 2]);

        /*
        int[] arr = new int[10];
        Scanner in = new Scanner(System.in);
        int i, min=0, max=0;
        for(i=0; i<=arr.length; i++)
        {
            System.out.print("Enter any number: ");
            arr[i] = in.nextInt();          
        }
        min = arr[0];
        for(i=0; i<=9; i++)
        {
            if(arr[i] > max)
            {
                max = arr[i];
            }
            if(arr[i] < min)
            {
                min = arr[i];
            }
        }
        System.out.println("Maximum is: " + max);
        System.out.println("Minimum is: " + min);
        */

    }
}

Answer 1

对于 unosorted 数据，循环遍历数组以查找min / max需要O（n）时间。对于已排序，它将是恒定时间（O（1）），但据我所知，这不是你的情况。

最快的排序算法在O（n * log（n））中工作，因此线性扫描（循环）是最快的选择。

此外，当编译器可以为您优化时，情况并非如此。

Answer 2

一般来说，你可以拥有的最快排序是O（nlogn），在数组上循环只是O（n）所以肯定是循环的

Answer 3

Arrays.sort（）使用mergesort算法的一个版本，该算法在O（nlog（n））中运行。通过线性搜索数组查找最大值和最小值只需要一次通过数组，使其成为O（n）。

通常，线性搜索循环方法运行得更快。您还可以将最大/最小发现与数据输入结合起来以提高效率：

   int[] arr = new int[10];
    Scanner in = new Scanner(System.in);
    int i, min=Integer.MAX_VALUE, max=Integer.MIN_VALUE;
    for(i=0; i<=arr.length; i++)
    {
        System.out.print("Enter any number: ");
        arr[i] = in.nextInt();   
        if (arr[i]>max) { max = arr[i]; }
        if (arr[i]<min) { min = arr[i]; } 
    }

Answer 4

您可以使用 JAVA 8 Stream API 。我认为Stream必须更快，因为它不存储元素。 Stream直接处理所需的元素。

代码示例：

List<Integer> integerList = Arrays.asList(1,2,13,4,15,6,17,8,19);
System.out.println("List of Ints= " +integerList);
IntSummaryStatistics intStats = integerList.stream().mapToInt((x) ->x).summaryStatistics();
System.out.println("Max Number= " + intStats.getMax());
System.out.println("Min Number= " + intStats.getMin());

我测试了代码＆amp;工作正常。

Answer 5

类似于其他答案

public class FindMaxAndMinFromArray {
static void findMaxAndMin(int[] arrNum) {
    Arrays.sort(arrNum);//will sort original array
    System.out.println("Min number is : " + arrNum[0]);//After sorting 0 index will be min value
    System.out.println("Max Number is : " + arrNum[arrNum.length - 1]); //last index will be max value
}

public static void main(String[] args) {
    int myArr[] = { 75,10, 20,80,65, 30, 40, 50 };
    findMaxAndMin(myArr);
}
}

Answer 6

迭代列表/数组以识别最小和最大条目可以一次完成。

除非您的数据已经排序，否则排序总是需要比单次读取所有条目更多的努力。

因此，在运行时排序只是找到min和max转换为一定量的开销。

当然：你的术语搞砸了。编译器将输入转换为输出，它并不关心您提供的代码作为输入的效率。

更快地找到数组中的最小值和最大值

6 个答案: