Java 为什么8个案例中有2个出现运行时错误？

我已经完成并通过了8个测试用例中的6个，使用以下代码对数组进行排序，然后增加max int出现的频率并打印该值：

import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;

public class Solution {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int numCandles = in.nextInt();
        int height[] = new int[numCandles];
        for(int height_i=0; height_i < numCandles; height_i++){
            height[height_i] = in.nextInt();
        }

        //Option 2: Sort the array, then count the number that are highest.
        Arrays.sort(height);
        int max = height[height.length - 1];
        int index = height.length - 1;
        int freq = 0;
        while(height[index] == max) {
            freq++;
            index--;
        }
        System.out.println(freq);
    }
}

import java.io.*；
导入java.util.*；
导入java.text.*；
导入java.math.*；
导入java.util.regex.*；
公共类解决方案{
公共静态void main（字符串[]args）{
扫描仪输入=新扫描仪（系统输入）；
int numCandles=in.nextInt（）；
int height[]=新int[numCandles]；
对于（int height_i=0；height_i

它没有通过测试用例6（）或测试用例7。简而言之，测试用例#6是100000次int 99999的出现，测试用例#7是100000次int 1的出现。两者的预期产量都应该是100000

---

我想它可能会遇到运行时错误，因为我在数组上调用了排序方法，而数组试图一次又一次地对相同值的整数进行排序？有人能解释为什么我的代码对这两个测试用例不起作用吗？

当输入中的所有值都相同时，就像在您包含的示例输入中一样，此循环中的条件将是

true

，直到

索引

减少到-1，此时您将得到

ArrayIndexOutOfBoundsException

：

将范围检查添加到循环条件，例如：

while (index >= 0 && height[index] == max) {

int numCandles = in.nextInt();
int heights[] = new int[numCandles];
int m = Integer.MIN_VALUE;
for (int i = 0; i < numCandles; i++) {
    heights[i] = in.nextInt();
    m = Math.max(m, heights[i]);
}

final int max = m;
long freq = IntStream.of(heights).filter(x -> x == max).count();
System.out.println(freq);

通过此更改，解决方案将通过所有测试。但这是一个低效的解决方案。您对输入进行了排序，以减少

while

循环中的迭代次数。但是排序是一种

O（n log（n））

操作，它比使用

O（n）

进行简单过滤要慢。例如：

while (index >= 0 && height[index] == max) {

int numCandles = in.nextInt();
int heights[] = new int[numCandles];
int m = Integer.MIN_VALUE;
for (int i = 0; i < numCandles; i++) {
    heights[i] = in.nextInt();
    m = Math.max(m, heights[i]);
}

final int max = m;
long freq = IntStream.of(heights).filter(x -> x == max).count();
System.out.println(freq);

int numCandles=in.nextInt（）；
整数高度[]=新整数[numCandles]；
int m=整数的最小值；
for（int i=0；ix==max.count（）；
系统输出打印项次（频率）；

当输入中的所有值与您包含的示例输入中的值相同时，此循环中的条件将为

true

，直到

索引减少到-1，此时您将获得
ArrayIndexOutOfBoundsException
：

将范围检查添加到循环条件，例如：

while (index >= 0 && height[index] == max) {

int numCandles = in.nextInt();
int heights[] = new int[numCandles];
int m = Integer.MIN_VALUE;
for (int i = 0; i < numCandles; i++) {
    heights[i] = in.nextInt();
    m = Math.max(m, heights[i]);
}

final int max = m;
long freq = IntStream.of(heights).filter(x -> x == max).count();
System.out.println(freq);

通过此更改，解决方案将通过所有测试。但这是一个低效的解决方案。您对输入进行了排序，以减少
while
循环中的迭代次数。但是排序是一种
O（n log（n））
操作，它比使用
O（n）
进行简单过滤要慢。例如：

while (index >= 0 && height[index] == max) {

int numCandles = in.nextInt();
int heights[] = new int[numCandles];
int m = Integer.MIN_VALUE;
for (int i = 0; i < numCandles; i++) {
    heights[i] = in.nextInt();
    m = Math.max(m, heights[i]);
}

final int max = m;
long freq = IntStream.of(heights).filter(x -> x == max).count();
System.out.println(freq);

int numCandles=in.nextInt（）；
整数高度[]=新整数[numCandles]；
int m=整数的最小值；
for（int i=0；ix==max.count（）；
系统输出打印项次（频率）；
您将得到一个异常的出站，因为当您小于0时，您将到达一个零件

while(height[index] == max) {

    freq++;
                if(index == 0)
        break;
    index--;
}   

这是我解决这个问题的办法

Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int height[] = new int[n];
        for(int height_i=0; height_i < n; height_i++){
            height[height_i] = in.nextInt();
        }
        Arrays.sort(height);
        int counter = 0;
        int different = height[n-1];
       for(int height_i=n-1; height_i >=0 ; height_i--){

           if(different ==height[height_i] )
            {
            counter = counter  + 1;   


           }
           else 
               {
               break;
           }

        }
        System.out.println(counter);
    }

Scanner-in=新的扫描仪（System.in）；
int n=in.nextInt（）；
整数高度[]=新整数[n]；
对于（int height_i=0；height_i=0；height\u i--）{
如果（不同==高度[高度i]）
{
计数器=计数器+1；
}
其他的
{
打破
}
}
系统输出打印项次（计数器）；
}

这是我的解决方案。我认为使用一段时间比使用一段时间更好。
您将得到一个异常的出站，因为当您到达一个零件时，小于0

while(height[index] == max) {

    freq++;
                if(index == 0)
        break;
    index--;
}   

这是我解决这个问题的办法

Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int height[] = new int[n];
        for(int height_i=0; height_i < n; height_i++){
            height[height_i] = in.nextInt();
        }
        Arrays.sort(height);
        int counter = 0;
        int different = height[n-1];
       for(int height_i=n-1; height_i >=0 ; height_i--){

           if(different ==height[height_i] )
            {
            counter = counter  + 1;   


           }
           else 
               {
               break;
           }

        }
        System.out.println(counter);
    }

Scanner-in=新的扫描仪（System.in）；
int n=in.nextInt（）；
整数高度[]=新整数[n]；
对于（int height_i=0；height_i=0；height\u i--）{
如果（不同==高度[高度i]）
{
计数器=计数器+1；
}
其他的
{
打破
}
}
系统输出打印项次（计数器）；
}

这是我的解决方案。我认为使用一段时间比使用一段时间更好。
简单的解决方案

static int birthdayCakeCandles(int[] arr) {
          int max = arr[0];
    int count = 0;
    for(int i =0; i<arr.length;i++) {

        if(max < arr[i]) {

            max = arr[i];
        }

    }
    for(int i =0; i<arr.length;i++) {

        if(max == arr[i]) {

            count++;
        }

    }
 return count;
}

静态int生日蜡烛（int[]arr）{
int max=arr[0]；
整数计数=0；
对于（int i=0；i简单解

static int birthdayCakeCandles(int[] arr) {
          int max = arr[0];
    int count = 0;
    for(int i =0; i<arr.length;i++) {

        if(max < arr[i]) {

            max = arr[i];
        }

    }
    for(int i =0; i<arr.length;i++) {

        if(max == arr[i]) {

            count++;
        }

    }
 return count;
}

静态int生日蜡烛（int[]arr）{
int max=arr[0]；
整数计数=0；
对于（int i=0；iArrr，当您运行此代码时会发生什么情况？您应该关闭输入扫描程序检查
while loop
，当索引变为小于零时。在调试器中运行它，看看会发生什么。这种方法在>90%的情况下有效。这种方法效率不高，在最坏的情况下有
O（n^2）
，在
O中有更好的方法（n） 
Arrr，运行此代码时会发生什么情况？您应该关闭输入扫描程序，检查索引小于零时，在
while循环中检查。在调试器中运行它，看看会发生什么情况。这种方法在>90%的情况下有效。这种方法效率不高，在最坏的情况下有
O（n^2）
，这是一个赌注