如何在二维数组中找到前5个最大值？

trnvg8h3  于 2021-06-30  发布在  Java
关注(0)|答案(6)|浏览(369)

我有一个二维整数数组。行和列信息（数字的位置）对我来说很重要。所以，我不想对数组（实际上是矩阵）排序。如何从这个二维数组中找到最高的5值？
这是我的密码：

for (int row = 0; row < matirx.length; row++) {
  for (int col = 0; col < matirx[row].length; col++) {
    if (matirx[row][col] > maxValue) {
      maxValue = matirx[row][col];
    }
  }
}
JavaArraysMax

6条答案

按热度按时间
i34xakig

i34xakig1#

您可以使用以下方法，这将给您带来以下好处：
保持非常简单的逻辑，因为您需要最高的5个值，并且不会丢失现有数组的任何索引位置/顺序，
用这个你会有更好的表现，
干净的代码。

public static void main(String[] args) {
    int[][] matrix = {
            {10, -5, 15},
            {8, 20, 12},
            {27, -3, 14},
            {7, 17, 4}};

    List<Integer> allVal = new ArrayList<>();

    for (int i = 0; i < matrix.length; i++) {
        for (int j = 0; j < matrix[i].length; j++) {
            allVal.add(matrix[i][j]);
        }
    }

    allVal = allVal.stream()
            .sorted(Comparator.reverseOrder())
            .limit(5)
            .collect(Collectors.toList());

    System.out.println(allVal);
}

输出：

[27, 20, 17, 15, 14]
赞(0）分享  回复(0）举报  2021-06-30
oalqel3c

oalqel3c2#

无需对数组本身进行排序，就可以 sorted 此数组上的流。或者可以实现一种按降序排列的选择排序。这两个代码示例执行相同的操作—在2d数组中查找前5个最高的不同值（如果存在）：

int[][] arr = {
        {1, 4, 7, 7},
        {2, 5, 8, 3},
        {5, 5, 1, 2},
        {3, 6, 0, 9}};

int[] max = Arrays.stream(arr)
        .flatMapToInt(Arrays::stream)
        .boxed().sorted(Comparator.reverseOrder())
        .mapToInt(Integer::intValue)
        .distinct()
        .limit(5)
        .toArray();

System.out.println(Arrays.toString(max)); // [9, 8, 7, 6, 5]
int[][] arr = {
        {1, 4, 7, 7},
        {2, 5, 8, 3},
        {5, 5, 1, 2},
        {3, 6, 0, 9}};

int[] max = new int[5];

for (int m = 0; m < max.length; m++) {
    int prev_max = m > 0 ? max[m - 1] : Integer.MAX_VALUE;
    for (int i = 0; i < arr.length; i++) {
        for (int j = 0; j < arr[i].length; j++) {
            if (arr[i][j] > max[m] && prev_max > arr[i][j]) {
                max[m] = arr[i][j];
            }
        }
    }
}

System.out.println(Arrays.toString(max)); // [9, 8, 7, 6, 5]

另请参见：数组的选择排序

赞(0）分享  回复(0）举报  2021-06-30
mhd8tkvw

mhd8tkvw3#

对于java8流，可以使用这（一）行代码来完成。它将保持原始矩阵不变。

Arrays.stream(matrix) // create a stream of the matrix
      .flatMapToInt(Arrays::stream) //Reduce 2d matrix to 1d 
      .boxed() //Convert int to Integer so we can sort reversed order
      .sorted(Collections.reverseOrder()) //sort array in reversed order highest first
      .limit(5) //Limit stream to 5 entries, the five top results
      .forEach(System.out::println); //Print the result
赞(0）分享  回复(0）举报  2021-06-30
qojgxg4l

qojgxg4l4#

首先，我选择了一个与其他答案非常相似的streams解决方案。我不喜欢拳击和拆箱的变化，但自从 IntStream 没有一个奇特的方法可以用 Comparator 开箱即用 IntStream 必须转换成 Stream 以便按相反的顺序对值进行排序。我不认为归还一张支票很重要 int[] 数组，因为我们只对值感兴趣。

public static Integer[] streamIt(int[][] matrix, int n){
  Integer[] result = 
    Arrays.stream(matrix)                                         // stream the arrays
          // This is the same as using .flatMaptoInt(..) and then .boxed()
          .flatMap(a -> Arrays.stream(a)                          // stream the array in arrays
                              .mapToObj(i -> Integer.valueOf(i))) // turn the ints into Integers
          .sorted(Comparator.reverseOrder())                      // sort by higest values
          .limit(n)                                               // only pick n
          .toArray(i -> new Integer[i]);                          // put then in Integer array
  return result;
}

如果你想让他们 int[] 相反，请看shadow.sabre使用 mapToInt() 你要怎么做。
虽然streams解决方案非常整洁，看起来也很干净，但我觉得问题其实只是为了得到一组最高的值，所以将它们插入到一个标准的java应用程序中 Set 对我来说很有意义。我首先将值插入到集合中，直到其中有5个元素。然后我检查新值是否高于最低值，如果是，则在插入新值时删除最低值。使用时很容易找到最低值 TreeSet 因为这是一个有序的集合。
诀窍是还要检查新值是否已经在集合中。如果集合中已经有5，4，3，2，1，并且新值是5，那么我不想删除最小值1，因为添加新值实际上不会向集合中添加任何新元素。还记得吗 Set 不能包含重复值：

public static Set<Integer> useSet(int[][] matrix, int n){
  TreeSet<Integer> max = new TreeSet<>(Comparator.<Integer>naturalOrder().reversed());
  for (int i = 0; i < matrix.length; i++) {
    for (int j = 0; j < matrix[i].length; j++) {
      // Keep adding values until there's n elements in the Set
      if (max.size() < n) { 
        max.add(matrix[i][j]);
      } else {
        // if the new value is higher than the lowest value
        //  ..and the new values isn't already there.
        if (max.last() < matrix[i][j] && !max.contains(matrix[i][j])) {
          max.pollLast();
          max.add(matrix[i][j]);
        }
      }
    }
  }
  return max;
}

请注意，此解决方案显然从不包含相同的值，而是始终包含顶部不同的值。
通过查看集合解决方案，可以很容易地添加跟踪矩阵中的值的位置的附加功能。我创建了一个类， Element ，以包含值及其位置。矩阵中要插入到 TreeSet 创建为 Element .
这个 Element 两个都需要 implement Comparable 或者 TreeSet 必须用 Comparator 以便对元素进行排序。这个例子 Element 两者都有，我只是用了 static Comparator 在执行 compareTo(Element that) 使之成为 Comparable<Element> . 通常情况下，您会使用getter实现带有私有字段的类来获取值，但为此，似乎有点冗长。使田地 final 也确保了类是不变的，所以我对它毫无顾忌。
由于比较是使用值和位置进行的，因此矩阵中的每个元素都是不同的：

class Element implements Comparable<Element> {
  final int value;
  final int x;
  final int y;

  static Comparator<Element> comparator = 
    Comparator.comparing((Element e) -> e.value)
              .thenComparing((Element e) -> e.x)
              .thenComparing((Element e) -> e.y)
              .reversed();

  Element(int value, int x, int y) {
    this.value = value;
    this.x = x;
    this.y = y;
  }

  public int compareTo(Element that){
    return comparator.compare(this, that);
  }

  public String toString(){
    return value + " at [" + x + "][" + y + "]";
  }
}

如果 Element 没有执行 Comparable 接口，这将是 TreeSet : TreeSet<Element> maxElement = new TreeSet<>(Element.comparator); 但是自从 Element 是否实现 Comparable 接口，集合实现可以在没有它的情况下初始化：

public static Set<Element> useSetElements(int[][] matrix, int n){
  TreeSet<Element> maxElement = new TreeSet<>();
  for (int i = 0; i < matrix.length; i++) {
    for (int j = 0; j < matrix[i].length; j++) {
      if (maxElement.size() < n) {
        maxElement.add(new Element(matrix[i][j],i,j));
      } else {
        if (maxElement.last().value < matrix[i][j]) {
          maxElement.pollLast();
          maxElement.add(new Element(matrix[i][j],i,j));
        }
      }
    }
  }
  return maxElement;
}

注意，因为每个元素都是不同的，所以不需要同时检查新值是否还不在集合中。
使用给定的输入运行三个解决方案：

int n = 5;
int[][] matrix = {{16, -20, 22, 19}, 
                  { 2,   5,  6,  8},
                  {17,  25, 16, 19},
                  { 7,  18,  4, 17}};

System.out.println("streamIt: \n "
                   + Arrays.toString(streamIt(matrix,n)));
System.out.println("useSet: \n "
                   + useSet(matrix,n));
System.out.println("useSetElements: \n "
                   + useSetElements(matrix,n));

..给出：

streamIt:
 [25, 22, 19, 19, 18]
useSet:
 [25, 22, 19, 18, 17]
useSetElements:
 [25 at [2][1], 22 at [0][2], 19 at [2][3], 19 at [0][3], 18 at [3][1]]

但是性能呢。。？

这三种不同的实现让我对性能感到疑惑，所以我添加了一个方法来计时执行：

static void timeMethod(Runnable toRun){
  long start = System.nanoTime();
  try{
    toRun.run();
  } finally {
    long end = System.nanoTime();
    System.out.println("  Time: " + (end - start)/1.0e6 + " miliseconds");
  }
}

运行了三种解决方案：

timeMethod(() -> System.out.println("streamIt: \n "
                                    + Arrays.toString(streamIt(matrix,n))));
timeMethod(() -> System.out.println("useSet: \n "
                                    + useSet(matrix,n)));
timeMethod(() -> System.out.println("useSetElements: \n "
                                    + useSetElements(matrix,n)));

…给出这个结果：

streamIt:
 [25, 22, 19, 19, 18]
  Time: 1.2759 miliseconds
useSet:
 [25, 22, 19, 18, 17]
  Time: 0.9343 miliseconds
useSetElements:
 [25 at [2][1], 22 at [0][2], 19 at [2][3], 19 at [0][3], 18 at [3][1]]
  Time: 1.16 miliseconds

似乎这三种解决方案的性能大致相同。streams解决方案似乎稍微慢一点。这个 Set 解决方案看起来很有前景，希望使用 Element 似乎要付出代价。但为了更深入地研究它，我决定在一个更大的矩阵上运行它们，我使用随机整数构建这个矩阵：

Random random = new Random();
int[][] largerMatrix =
  IntStream.range(0,10000)                     // 10000 on the first dimension
           .mapToObj(i -> random.ints(0,128)   // values between 0 and 128 (not included)
                                .limit(10000)  // 10000 on the second dimension
                                .toArray())    // make the second 1D arrays
           .toArray(int[][]::new);             // put them into a 2D array

使用10000 x 10000矩阵运行测试：

timeMethod(() -> System.out.println("streamIt: \n "
                                    + Arrays.toString(streamIt(largerMatrix,n))));
timeMethod(() -> System.out.println("useSet: \n "
                                    + useSet(largerMatrix,n)));
timeMethod(() -> System.out.println("useSetElements: \n "
                                    + useSetElements(largerMatrix,n)));

..给出了这个结果：

streamIt:
 [127, 127, 127, 127, 127]
  Time: 90374.6995 miliseconds
useSet:
 [127, 126, 125, 124, 123]
  Time: 2465.2448 miliseconds
useSetElements:
 [127 at [0][310], 127 at [0][277], 127 at [0][260], 127 at [0][81], 127 at [0][61]]
  Time: 1839.7323 miliseconds

在这里，streams解决方案似乎非常慢！这个 Element 解决方案是两者的赢家 Set 解决。我想是因为 Element 只有在需要插入到 Set 它正在做一个直线上升 int 比较，而另一个 Set 解决方案是每次比较值时取消装箱。不过，我没有进一步验证我的假设。
我对这个线程中其他解决方案的好奇心也让我测试了这些。试验溶液为：
阿文德库马尔阿维纳什的回答
anurag jain的回答
迈克尔·查蒂斯卡齐的回答
在小型和大型阵列上运行测试：

System.out.println("--- Testing performance ---");
timeMethod(() -> System.out.println("ArvindKumarAvinash: \n "
                                    + Arrays.toString(ArvindKumarAvinash(matrix,n))));
timeMethod(() -> System.out.println("AnuragJain: \n "
                                    + AnuragJain(matrix,n)));
timeMethod(() -> System.out.println("MichaelChatiskatzi: \n "
                                    + Arrays.toString(MichaelChatiskatzi(matrix,n))));

System.out.println();
System.out.println("--- Testing performance with largeMatrix---");
timeMethod(() -> System.out.println("ArvindKumarAvinash: \n "
                                    + Arrays.toString(ArvindKumarAvinash(largerMatrix,n))));
timeMethod(() -> System.out.println("AnuragJain: \n "
                                    + AnuragJain(largerMatrix,n)));
timeMethod(() -> System.out.println("MichaelChatiskatzi: \n "
                                    + Arrays.toString(MichaelChatiskatzi(largerMatrix,n))));

…给出了这些结果：

--- Testing performance ---
ArvindKumarAvinash:
 [25, 22, 19, 19, 18]
  Time: 0.9076 miliseconds
AnuragJain:
 [25, 22, 19, 19, 18]
  Time: 6.2277 miliseconds
MichaelChatiskatzi:
 [18, 19, 19, 22, 25]
  Time: 1.2204 miliseconds

--- Testing performance with largeMatrix---
ArvindKumarAvinash:
 [127, 127, 127, 127, 127]
  Time: 3381.1387 miliseconds
AnuragJain:
 [127, 127, 127, 127, 127]
  Time: 120244.7063 miliseconds
MichaelChatiskatzi:
 [127, 127, 127, 127, 127]
  Time: 51.4259 miliseconds

似乎使用流的解决方案一点性能都不高。MichaelChatiskatzi的解决方案是迄今为止性能更好的解决方案。

所有代码

如果你想自己运行，这里有一个复制粘贴运行的完整类：

import java.util.Arrays;
import java.util.Comparator;
import java.util.stream.IntStream;
import java.util.Set;
import java.util.TreeSet;
import java.util.Comparator;
import java.util.Random;
import java.util.List;
import java.util.ArrayList;
import java.util.stream.Collectors;

public class GettingTheTopN {
    public static void main(String[] args) {
      int n = 5;
      int[][] matrix = {{16, -20, 22, 19}, 
                        { 2,   5,  6,  8},
                        {17,  25, 16, 19},
                        { 7,  18,  4, 17}};

      System.out.println("streamIt: \n "
                         + Arrays.toString(streamIt(matrix,n)));
      System.out.println("useSet: \n "
                         + useSet(matrix,n));
      System.out.println("useSetElements: \n "
                         + useSetElements(matrix,n));

      System.out.println();
      System.out.println("--- Testing performance ---");

      timeMethod(() -> System.out.println("streamIt: \n "
                                          + Arrays.toString(streamIt(matrix,n))));
      timeMethod(() -> System.out.println("useSet: \n "
                                          + useSet(matrix,n)));
      timeMethod(() -> System.out.println("useSetElements: \n "
                                          + useSetElements(matrix,n)));
      timeMethod(() -> System.out.println("ArvindKumarAvinash: \n "
                                          + Arrays.toString(ArvindKumarAvinash(matrix,n))));
      timeMethod(() -> System.out.println("AnuragJain: \n "
                                          + AnuragJain(matrix,n)));
      timeMethod(() -> System.out.println("MichaelChatiskatzi: \n "
                                          + Arrays.toString(MichaelChatiskatzi(matrix,n))));

      System.out.println();
      System.out.println("--- Testing performance with largeMatrix---");

      Random random = new Random();
      int[][] largerMatrix =
        IntStream.range(0,10000)                     // 10000 on the first dimension
                 .mapToObj(i -> random.ints(0,128)   // values between 0 and 128 (not included)
                                      .limit(10000)  // 10000 on the second dimension
                                      .toArray())    // make the second 1D arrays
                 .toArray(int[][]::new);             // put them into a 2D array

      timeMethod(() -> System.out.println("streamIt: \n "
                                          + Arrays.toString(streamIt(largerMatrix,n))));
      timeMethod(() -> System.out.println("useSet: \n "
                                          + useSet(largerMatrix,n)));
      timeMethod(() -> System.out.println("useSetElements: \n "
                                          + useSetElements(largerMatrix,n)));
      timeMethod(() -> System.out.println("ArvindKumarAvinash: \n "
                                          + Arrays.toString(ArvindKumarAvinash(largerMatrix,n))));
      timeMethod(() -> System.out.println("AnuragJain: \n "
                                          + AnuragJain(largerMatrix,n)));
      timeMethod(() -> System.out.println("MichaelChatiskatzi: \n "
                                          + Arrays.toString(MichaelChatiskatzi(largerMatrix,n))));
    }

    public static Integer[] streamIt(int[][] matrix, int n){
      Integer[] result = 
        Arrays.stream(matrix)                                         // stream the arrays
              // This is the same as using .flatMaptoInt(..) and then .boxed()
              .flatMap(a -> Arrays.stream(a)                          // stream the array in arrays
                                  .mapToObj(i -> Integer.valueOf(i))) // turn the ints into Integers
              .sorted(Comparator.reverseOrder())                      // sort by higest values
              .limit(n)                                               // only pick n
              .toArray(i -> new Integer[i]);                          // put then in Integer array
      return result;
    }

    public static Set<Integer> useSet(int[][] matrix, int n){
      TreeSet<Integer> max = new TreeSet<>(Comparator.<Integer>naturalOrder().reversed());
      for (int i = 0; i < matrix.length; i++) {
        for (int j = 0; j < matrix[i].length; j++) {
          // Keep adding values until there's n elements in the Set
          if (max.size() < n) { 
            max.add(matrix[i][j]);
          } else {
            // if the new value is higher than the lowest value
            //  ..and the new values isn't already there.
            if (max.last() < matrix[i][j] && !max.contains(matrix[i][j])) {
              max.pollLast();
              max.add(matrix[i][j]);
            }
          }
        }
      }
      return max;
    }

    public static Set<Element> useSetElements(int[][] matrix, int n){
      TreeSet<Element> maxElement = new TreeSet<>();
      for (int i = 0; i < matrix.length; i++) {
        for (int j = 0; j < matrix[i].length; j++) {
          if (maxElement.size() < n) {
            maxElement.add(new Element(matrix[i][j],i,j));
          } else {
            if (maxElement.last().value < matrix[i][j]) {
              maxElement.pollLast();
              maxElement.add(new Element(matrix[i][j],i,j));
            }
          }
        }
      }
      return maxElement;
    }

    // ----------------- Performance

    static void timeMethod(Runnable toRun){
      long start = System.nanoTime();
      try{
        toRun.run();
      } finally {
        long end = System.nanoTime();
        System.out.println("  Time: " + (end - start)/1.0e6 + " miliseconds");
      }
    }

    // [Answer to "How to find first 5 highest value in a two dimensional array?"](https://stackoverflow.com/a/65374950/12695027) by [Arvind Kumar Avinash](https://stackoverflow.com/users/10819573/arvind-kumar-avinash)
    static int[] ArvindKumarAvinash(int[][] matrix, int MAX_N) {
        // Find count as the total number of elements
        int count = 0, row, col;
        for (row = 0; row < matrix.length; row++) {
            count += matrix[row].length;
        }

        // Create flattened = new int[count] and fill it with all elements of matrix[][]
        int[] flattened = new int[count];
        int i = 0;
        for (row = 0; row < matrix.length; row++) {
            for (col = 0; col < matrix[row].length; col++) {
                flattened[i++] = matrix[row][col];
            }
        }

        // Create max = new int[MAX_N] to store maximum n numbers.
        // Also, create maxPos = new int[MAX_N] to store the position of the maximum numbers.
        int[] max = new int[MAX_N];
        int[] maxPos = new int[MAX_N];

        // Loop MAX_N times. In each iteration, assume flattened[0] is the largest number.
        for (i = 0; i < max.length; i++) {
            max[i] = flattened[0];

            for (int j = 1; j < flattened.length; j++) {
                // If flattened[j] >= max[i], check if the position, j has already been
                // processed. If not assign flattened[j] to max[i] and j to maxPos[i].
                if (flattened[j] >= max[i]) {
                    boolean posAlreadyProcessed = false;
                    for (int k = 0; k <= i; k++) {
                        if (maxPos[k] == j) {
                            posAlreadyProcessed = true;
                            break;
                        }
                    }
                    if (!posAlreadyProcessed) {
                        max[i] = flattened[j];
                        maxPos[i] = j;
                    }
                }
            }
        }

        return max;
        // System.out.println("Largest " + MAX_N + " values: " + Arrays.toString(max));
    }

    // [Answer to "How to find first 5 highest value in a two dimensional array?"](https://stackoverflow.com/a/65380541/12695027) by [Anurag Jain](https://stackoverflow.com/users/5825625/anurag-jain)
    static List<Integer> AnuragJain(int[][] matrix, int n) {
      List<Integer> allVal = new ArrayList<>();

     for (int i = 0; i < matrix.length; i++) {
         for (int j = 0; j < matrix[i].length; j++) {
             allVal.add(matrix[i][j]);
         }
     }
      allVal = allVal.stream()
                     .sorted(Comparator.reverseOrder())
                     .limit(n).collect(Collectors.toList());
      return allVal;
      // System.out.println(allVal);
    }

    // [Answer to "How to find first 5 highest value in a two dimensional array?"](https://stackoverflow.com/a/65379921/12695027) by [Michael Chatiskatzi](https://stackoverflow.com/users/11263320/michael-chatiskatzi)
    static int[] MichaelChatiskatzi(int[][] matrix, int n) {
        // int[] highestNumbers = new int[5];
        int[] highestNumbers = new int[n];
        Arrays.fill(highestNumbers, Integer.MIN_VALUE);
        for (int row = 0; row < matrix.length; row++) {
            for (int column = 0; column < matrix[row].length; column++) {
                int currentEntry = matrix[row][column];
                if (currentEntry > highestNumbers[0]) {
                    highestNumbers[0] = currentEntry;
                    Arrays.sort(highestNumbers);
                }
            }
        }
        return highestNumbers;
        // System.out.println(Arrays.toString(highestNumbers));
    }
}

// -------------------------------------------
// -------------------------------------------
class Element implements Comparable<Element> {
  final int value;
  final int x;
  final int y;

  static Comparator<Element> comparator = 
    Comparator.comparing((Element e) -> e.value)
              .thenComparing((Element e) -> e.x)
              .thenComparing((Element e) -> e.y)
              .reversed();

  Element(int value, int x, int y) {
    this.value = value;
    this.x = x;
    this.y = y;
  }

  public int compareTo(Element that){
    return comparator.compare(this, that);
  }

  public String toString(){
    return value + " at [" + x + "][" + y + "]";
  }
}
赞(0）分享  回复(0）举报  2021-06-30
vcudknz3

vcudknz35#

让 MAX_N = 5 .
查找 count 作为 matrix[][] .
创建 flattened = new int[count] 把所有的元素都填满 matrix[][] .
create max=new int[max\n]以存储最大n个数字。另外，创建maxpos=newint[max\n]来存储最大数字的位置。
回路 MAX_N 在每次迭代中，假设 flattened[0] 是最大的数字。
如果 flattened[j] >= max[i] ，检查位置， j 已处理。如果未分配 flattened[j] 至 max[i] 以及 j 至 maxPos[i] .
演示：

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        final int MAX_N = 5;
        int[][] matrix = {
                {16, -20, 11, 19},
                {2, 5, 6, 8},
                {17, 25, 16, 19},
                {7, 17, 4, 17}};

        // Find count as the total number of elements
        int count = 0, row, col;
        for (row = 0; row < matrix.length; row++) {
            count += matrix[row].length;
        }

        // Create flattened = new int[count] and
        // fill it with all elements of matrix[][]
        int[] flattened = new int[count];
        int i = 0;
        for (row = 0; row < matrix.length; row++) {
            for (col = 0; col < matrix[row].length; col++) {
                flattened[i++] = matrix[row][col];
            }
        }

        // Create max = new int[MAX_N] to store maximum 
        // n numbers. Also, create maxPos = new int[MAX_N]
        // to store the position of the maximum numbers.
        int[] max = new int[MAX_N];
        int[] maxPos = new int[MAX_N];

        // Loop MAX_N times. In each iteration,
        // assume flattened[0] is the largest number.
        for (i = 0; i < max.length; i++) {
            max[i] = flattened[0];

            for (int j = 1; j < flattened.length; j++) {
                // If flattened[j] >= max[i], check if the
                // position, j has already been processed.
                // If not assign flattened[j] to max[i]
                // and j to maxPos[i].
                if (flattened[j] >= max[i]) {
                    boolean posAlreadyProcessed = false;
                    for (int k = 0; k <= i; k++) {
                        if (maxPos[k] == j) {
                            posAlreadyProcessed = true;
                            break;
                        }
                    }
                    if (!posAlreadyProcessed) {
                        max[i] = flattened[j];
                        maxPos[i] = j;
                    }
                }
            }
        }
        System.out.println("Largest " + MAX_N +
                " values: " + Arrays.toString(max));
    }
}

输出：

Largest 5 values: [25, 19, 19, 17, 17]
赞(0）分享  回复(0）举报  2021-06-30
rlcwz9us

rlcwz9us6#

既然这个问题又有了答案，我将发表我的评论。
我没有在同一个矩阵上迭代多次，而是填充 int[] highestNumbers 与 Integer.MIN_VALUE ，在矩阵上迭代一次，并通过更新 highestNumbers 然后分类。

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[][] matrix = {
                {10, -5, 15},
                {8, 20, 12},
                {27, -3, 14},
                {7, 17, 4}};
        int[] highestNumbers = new int[5];
        Arrays.fill(highestNumbers, Integer.MIN_VALUE);
        for (int row = 0; row < matrix.length; row++) {
            for (int column = 0; column < matrix[row].length; column++) {
                int currentEntry = matrix[row][column];
                if (currentEntry > highestNumbers[0]) {
                    highestNumbers[0] = currentEntry;
                    Arrays.sort(highestNumbers);
                }
            }
        }
        System.out.println(Arrays.toString(highestNumbers));
    }
}

输出：

[14, 15, 17, 20, 27]
赞(0）分享  回复(0）举报  2021-06-30
我来回答

相关问题

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新问答

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com