Question

我正在尝试创建一个程序，该程序从学生成绩数组的集合中打印出最高整数，但每次返回一个值时代码都会返回相同的值。

到目前为止，这是代码：

class BestGrades {
public static void main(String args[]){
            Scanner sc = new Scanner(System.in);

            int grade[] = new int[6];
            int best[] = new int[3];

            System.out.println("Enter the student's grade...");

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

                    grade[i] = sc.nextInt();

                    for(int a = 0; a < best.length; a++){
                            if(grade[i] > best[a]){
                                    best[a] = grade[i];
                            }
                    }
            }

            for(int i = 0; i < best.length; i++){
                    System.out.println("Best degrees are: "+best[i]);
            }
    }

}

正如我所说，代码将始终返回相同的最高值3x。请原谅我有任何错误，第一次问这里。

Answer 1

for(int a = 0; a < best.length; a++){
    if(grade[i] > best[a]){
        for(int b = a + 1; b < best.length; b++){
            best[b] = best[b - 1];
        }
        best[a] = grade[i];
        break;
    }
}

Answer 2

你必须跟踪哪个是你最好的阵列中的较低等级，只替换那个

class BestGrades {
public static void main(String args[]){
        Scanner sc = new Scanner(System.in);

        int grade[] = new int[6];
        int best[] = new int[3];

        System.out.println("Enter the student's grade...");

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

                grade[i] = sc.nextInt();

                boolean better = false;
                int lowerIndex = 0;

                for(int a = 0; a < best.length; a++){
                        if(grade[i] > best[a]){
                                better = true;
                        }
                        if(best[a] < best[lowerIndex]){
                            lowerIndex = a;
                        }
                }
                if(better){
                    best[lowerIndex] = grade[i];
                }
        }

        for(int i = 0; i < best.length; i++){
                System.out.println("Best degrees are: "+best[i]);
        }
    }
}

Answer 3

我还没有测试过，但这样的事情应该有用。它找到最佳数组中的最小值，如果新值大于该值，则它是最佳值之一并替换原始最小值。与大卫的答案类似，但有点简单。

// Start best values at negative infinite so that the worst grade
// is still better that what's initially stored
best = {Integer.MIN_VALUE, Integer.MIN_VALUE, Integer.MIN_VALUE};

for(int i = 0; i < grade.length; i++){
    grade[i] = sc.nextInt();

    // find min value of the max values
    // start by setting first value as the min
    int minIndex = 0;

    for(int a = 1; a < best.length; a++){
        if(best[a] < best[minIndex]) {
            minIndex = a;
        }
    }

    // place new grade into best array if it is better
    // than the worst best value
    if(grade[i] > best[minIndex])
        best[minIndex] = grade[i];
}

Answer 4

攻击这样的问题的方法是将其分解成更小的部分。一种方式是自上而下 - 当一些东西看起来很难在线时，调用一个方法（不存在）来做它。然后写下那个方法。

  for( grade : grades) {
      replaceLowestIfHigher(grade, best);
  }

现在我们只需要写replaceLowestIfHigher()：

  public void replaceLowestIfHigher(int grade, int[] target) {
      int indexOfLowest = findIndexOfLowest(target);

      if(grade > target[indexOfLowest]) {
         target[indexOfLowest] = grade;
      }
  }

...现在我们必须写findIndexOfLowest()：

 public int findIndexOfLowest(int[] array) { 
      int indexOfLowest=0;
      for(int i=1; i<array.length; i++) {
         if(array[i] < array[indexOfLowest]) {
              indexOfLowest = i;
         }
      }
      return indexOfLowest;
 }

唯一的问题是你在目标数组中搜索最低值，即使你之前可能已经为相同的值完成了它。您可以通过多种方式存储这些知识 - 例如，您可以创建一个类来管理“最佳”数组，该数组会记住最低数据的位置，并且仅在数据更改时重新计算：

public class BestGrades {
    private int[] grades = new int[3];
    private int indexOfLowest = 0;

    public int[] getGrades() {
        return grades;
    }

    public void replaceLowestIfHigher(int grade) {
       if(grade > grades[indexOfLowest]) {
          grades[indexOfLowest] = grade;
          updateIndexOfLowest();
       }
    }

    private void updateIndexOfLowest() {
        indexOfLowest = 0;
        for(int i=1; i<target.length; i++) {
            if(grades[i] < grades[indexOfLowest]) {
                indexOfLowest = i;
            }
         }
    }
}

但是，大多数成熟的Java程序员都会使用排序集合来实现这一目标。

Answer 5

您可以尝试以功能样式解决此问题。使用前面描述的策略：

遍历数组并查找当前元素是否优于最佳音符数组中的某个项目。
如果是，那么找到数组中最小的最佳音符并捕捉其位置
使用2中的位置将当前项目复制到最佳音符数组。

这是可以捕获N个最佳音符的功能替代方案：

public static int[] findNHighest2(int[] array, int limit) {
    return IntStream.range(0, array.length).boxed().collect(() -> new int[limit], (a, i) -> { // collect in array with specified size.
        IntStream.range(0, limit).boxed().filter(j -> array[i] > a[j]).findFirst().ifPresent(k -> { // finding if there is an item larger than the best ones
            int minPos = findMinPos(a, limit); // find the minimum of the best ones
            a[minPos] = array[i]; // copy the new best item to our best item array
        });
    }, (a, i) -> {});
}

private static int findMinPos(int[] array, int limit) {
    return IntStream.range(0, limit)
            .reduce((i,j) -> array[i] > array[j] ? j : i)
            .getAsInt();
}

用法：

public static void main(String[] args) throws IOException {
    int[] arr = {9, 3,1, 9, 2, 7, 11, 2, 1, -1, 100, 8, 9, 199, 2};
    System.out.println(Arrays.toString(findNHighest(arr.clone(), 6)));
}

控制台上的结果：

[9, 199, 11, 9, 100, 9]

从数组中打印3个最高整数而不进行排序

5 个答案: