使用Java查找矩阵最小值和最大值的替代方法 packagemyarray； // https://github.com/javadevelopcom/ArrayVsArrayList/blob/master/src/myArray/MatrixMinMax.java 公共类矩阵{ 公共静态无效矩阵xminmax（）{ System.out.println（“矩阵是数字、符号或表达式的矩形数组：“+”\n”）； int[][]矩阵={ {10, 10, 10, 10, -10}, {20, 20, 20, -20, 20}, {30, 30, -30, 30, 30}, {40, -40, 40, 40, 40}, {-50, 50, 50, 50, 50}}; 对于（int i=0；ip1.compareTo（p2））.get（）.intValue（）； System.out.println（“MIN:+MIN”）； System.out.println（“MAX:+MAX”）；

矩阵数组min-max，二维数组尽管这只是推测，取决于整体上下文，但不可能在实际数据成员中搜索最大值和最小值

package myArray;
// https://github.com/javadevelopcom/ArrayVsArrayList/blob/master/src/myArray/MatrixMinMax.java
public class MatrixMinMax {

    public static void matrixMinMax() {
        System.out.println("Matrix is a rectangular array of numbers, symbols, or expressions:" + "\n");

        int[][] matrix = {
                {10, 10, 10, 10, -10},
                {20, 20, 20, -20, 20},
                {30, 30, -30, 30, 30},
                {40, -40, 40, 40, 40},
                {-50, 50, 50, 50, 50}};

        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix.length; j++) System.out.print(matrix[i][j] + " ");
            System.out.println();
        }
        int min = matrix[0][0];
        int max = matrix[0][0];

        for (int[] ints : matrix) {
            for (int i : ints) {
                if (i < min) {
                    min = i;
                }
                if (i > max) {
                    max = i;
                }
            }
        }
        System.out.println("MIN: " + min);
        System.out.println("MAX: " + max);
    }
}

但是使用一些自定义方法来设置条目；此方法将对其他成员执行一些检查

int[][] matrix

如有必要，请更换。这种方法可以按如下方式实现，并且可以在上述成员中访问最大值和最小值

int maximum = Integer.MIN_VALUE;
int minimum = Integer.MAX_VALUE;

---

但是，这种方法基本上是用搜索矩阵的时间来换取设置矩阵条目的时间。

尽管这只是推测，但根据整体上下文，可能无法在实际数据成员中搜索最大值和最小值

package myArray;
// https://github.com/javadevelopcom/ArrayVsArrayList/blob/master/src/myArray/MatrixMinMax.java
public class MatrixMinMax {

    public static void matrixMinMax() {
        System.out.println("Matrix is a rectangular array of numbers, symbols, or expressions:" + "\n");

        int[][] matrix = {
                {10, 10, 10, 10, -10},
                {20, 20, 20, -20, 20},
                {30, 30, -30, 30, 30},
                {40, -40, 40, 40, 40},
                {-50, 50, 50, 50, 50}};

        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix.length; j++) System.out.print(matrix[i][j] + " ");
            System.out.println();
        }
        int min = matrix[0][0];
        int max = matrix[0][0];

        for (int[] ints : matrix) {
            for (int i : ints) {
                if (i < min) {
                    min = i;
                }
                if (i > max) {
                    max = i;
                }
            }
        }
        System.out.println("MIN: " + min);
        System.out.println("MAX: " + max);
    }
}

但是使用一些自定义方法来设置条目；此方法将对其他成员执行一些检查

int[][] matrix

如有必要，请更换。这种方法可以按如下方式实现，并且可以在上述成员中访问最大值和最小值

int maximum = Integer.MIN_VALUE;
int minimum = Integer.MAX_VALUE;

---

但是，这种方法基本上是用搜索矩阵的时间来换取设置矩阵项的时间。

其中一种方法是将二维数组转换为1D列表，并使用流API来获取最小值和最大值

在上面的代码中，我们应该使用

Integer

数组，而不是

int

数组。考虑下面的实现。代码行数减少

void setEntry(int i, int j, in value)
{
    matrix[i][j] = value;
    minimum = Math.min(value, minimum);
    maximum = Math.max(value, maximum);
}

Integer[][]矩阵={
{10, 10, 10, 10, -10},
{20, 20, 20, -20, 20},
{30, 30, -30, 30, 30},
{40, -40, 40, 40, 40},
{-50, 50, 50, 50, 50}};
列表=新的ArrayList（）；
对于（整数[]数组：矩阵）
addAll（Arrays.asList（array））；
int max=list.stream（）.max（（p1，p2）->p1.compareTo（p2））.get（）.intValue（）；
int min=list.stream（）.min（（p1，p2）->p1.compareTo（p2））.get（）.intValue（）；
System.out.println（“MIN:+MIN”）；
System.out.println（“MAX:+MAX”）；

方法之一是将二维数组转换为一维列表，并使用流API获取最小值和最大值

在上面的代码中，我们应该使用

Integer

数组，而不是

int

数组。考虑下面的实现。代码行数减少

void setEntry(int i, int j, in value)
{
    matrix[i][j] = value;
    minimum = Math.min(value, minimum);
    maximum = Math.max(value, maximum);
}

Integer[][]矩阵={
{10, 10, 10, 10, -10},
{20, 20, 20, -20, 20},
{30, 30, -30, 30, 30},
{40, -40, 40, 40, 40},
{-50, 50, 50, 50, 50}};
列表=新的ArrayList（）；
对于（整数[]数组：矩阵）
addAll（Arrays.asList（array））；
int max=list.stream（）.max（（p1，p2）->p1.compareTo（p2））.get（）.intValue（）；
int min=list.stream（）.min（（p1，p2）->p1.compareTo（p2））.get（）.intValue（）；
System.out.println（“MIN:+MIN”）；
System.out.println（“MAX:+MAX”）；

这并不是问题的确切答案，但我认为它揭示了一些问题，并给出了一些理论上的改进

如果您想要O（n）复杂度时间，您应该更改循环的嵌套迭代：

            Integer[][] matrix = {
            {10, 10, 10, 10, -10},
            {20, 20, 20, -20, 20},
            {30, 30, -30, 30, 30},
            {40, -40, 40, 40, 40},
            {-50, 50, 50, 50, 50}};

            List<Integer> list = new ArrayList<Integer>();
            for (Integer[] array : matrix)
                list.addAll(Arrays.asList(array));
            int max = list.stream().max((p1, p2) -> p1.compareTo(p2)).get().intValue();
            int min = list.stream().min((p1, p2) -> p1.compareTo(p2)).get().intValue();
            System.out.println("MIN: " + min);
            System.out.println("MAX: " + max);

//在O（n^2）中
for（int[]int:matrix）{
for（整数i:整数）{
如果（imax）{
max=i；
}
}
}

例如：

 //in O(n^2)
 for (int[] ints : matrix) {
            for (int i : ints) {
                if (i < min) {
                    min = i;
                }
                if (i > max) {
                    max = i;
                }
            }
        }

for（i=0；i这并不是问题的确切答案，但我认为它揭示了一些问题，并给出了一些理论上的改进

如果您想要O（n）复杂度时间，您应该更改循环的嵌套迭代：

            Integer[][] matrix = {
            {10, 10, 10, 10, -10},
            {20, 20, 20, -20, 20},
            {30, 30, -30, 30, 30},
            {40, -40, 40, 40, 40},
            {-50, 50, 50, 50, 50}};

            List<Integer> list = new ArrayList<Integer>();
            for (Integer[] array : matrix)
                list.addAll(Arrays.asList(array));
            int max = list.stream().max((p1, p2) -> p1.compareTo(p2)).get().intValue();
            int min = list.stream().min((p1, p2) -> p1.compareTo(p2)).get().intValue();
            System.out.println("MIN: " + min);
            System.out.println("MAX: " + max);

//在O（n^2）中
for（int[]int:matrix）{
for（整数i:整数）{
如果（imax）{
max=i；
}
}
}

例如：

 //in O(n^2)
 for (int[] ints : matrix) {
            for (int i : ints) {
                if (i < min) {
                    min = i;
                }
                if (i > max) {
                    max = i;
                }
            }
        }

for（i=0；i或者您可以轻松使用lambdas查找数组的最小值和最大值，如下所示：

for(i = 0; i<(X*Y); i++)

或者您可以轻松使用lambdas查找数组的最小值和最大值，如下所示：

for(i = 0; i<(X*Y); i++)

我认为你不能比O（n^2）做得更好；因为这些数字没有排序，或者没有任何特定的属性（比如，它们都适合某个范围），您必须访问每一个数字，以确保它是否修改了现有的最大值/最小值。访问所有数字会进行n^2次操作
我认为您做得再好不过了O（n^2）；因为这些数字没有排序，或者没有任何特定属性（例如，它们都适合某个范围），您必须访问