java - long - Explicación sobre Integer.MAX_VALUE y Integer.MIN_VALUE para encontrar el valor mínimo y máximo en una matriz

integer.max_value java

Question

Parece que no entiendo cómo Integer.MAX_VALUE y Integer.MIN_VALUE ayudan a encontrar el valor mínimo y máximo en una matriz.

Entiendo cómo funciona este método (seudocódigo a continuación) al encontrar los valores mínimo y máximo:

max = A[0], min = A[0]
for each i in A
  if A[i] > max then max = A[i]
  if A[i] < min then min = A[i] 

Pero en cuanto a este método, no entiendo el propósito de Integer.MAX_VALUE y Integer.MIN_VALUE :

import java.util.Scanner;

class MyClass {

    public static void main(String[] args) {

        int[] numbers; // declaring the data type of numbers
        numbers = new int[3]; //assigning the number of values numbers will contain
        int smallest = Integer.MAX_VALUE, largest = Integer.MIN_VALUE;

        Scanner input = new Scanner(System.in);

        System.out.println("Please enter 3 numbers");

        for(int counter = 0; counter<numbers.length;counter++) {
            numbers[counter] = input.nextInt();
        }

        for(int i = 0; i<numbers.length; i++) {
            if(numbers[i]<smallest)
                smallest = numbers[i];
            else if(numbers[i]>largest)
                largest = numbers[i];
        }

        System.out.println("Largest is "+largest);
        System.out.println("Smallest is "+smallest);
    }

}

• System.out.println (Integer.MAX_VALUE) da 2147483647
• System.out.println (Integer.MIN_VALUE) da -2147483648

Entonces, ¿para qué sirven las comparaciones Integer.MIN_VALUE y Integer.MIN_VALUE?

Answer 1

pero en cuanto a este método, no entiendo el propósito de Integer.MAX_VALUE y Integer.MIN_VALUE.

Al comenzar con el conjunto smallest para Integer.MAX_VALUE y el conjunto largest para Integer.MIN_VALUE , no tienen que preocuparse más adelante por el caso especial en el que el smallest y el smallest largest aún no tienen un valor. Si los datos que estoy buscando tienen un 10 como primer valor, entonces los numbers[i]<smallest serán verdaderos (porque 10 es < Integer.MAX_VALUE ) y actualizaremos los smallest para que sean 10 . De manera similar, los numbers[i]>largest serán true porque 10 es > Integer.MIN_VALUE y actualizaremos los largest . Y así.

Por supuesto, al hacer esto, debe asegurarse de tener al menos un valor en los datos que está viendo. De lo contrario, terminas con números apócrifos en los smallest y largest .

Note el punto que Onome Sotu hace en los comentarios:

... si el primer elemento de la matriz es más grande que el resto, entonces el elemento más grande siempre será Integer.MIN_VALUE debido a la sentencia else-if.

Cual es verdad; Aquí hay un ejemplo más simple que demuestra el problema ( copia en vivo ):

public class Example
{
    public static void main(String[] args) throws Exception {
        int[] values = {5, 1, 2};
        int smallest = Integer.MAX_VALUE;
        int largest  = Integer.MIN_VALUE;
        for (int value : values) {
            if (value < smallest) {
                smallest = value;
            } else if (value > largest) {
                largest = value;
            }
        }
        System.out.println(smallest + ", " + largest); // 1, 2 -- WRONG
    }
}

Para arreglarlo, ya sea:

1. No uses else , o

2. Comience con el smallest y el largest igual al primer elemento, y luego haga un bucle con los elementos restantes, manteniendo el else if .

Aquí hay un ejemplo de ese segundo ( copia en vivo ):

public class Example
{
    public static void main(String[] args) throws Exception {
        int[] values = {5, 1, 2};
        int smallest = values[0];
        int largest  = values[0];
        for (int n = 1; n < values.length; ++n) {
            int value = values[n];
            if (value < smallest) {
                smallest = value;
            } else if (value > largest) {
                largest = value;
            }
        }
        System.out.println(smallest + ", " + largest); // 1, 5
    }
}

Answer 2

Al inicializar los valores mínimos / máximos en su extremo opuesto, evita los casos de valores de borde en la entrada: cualquiera de los valores mínimos / máximos es, de hecho, uno de esos valores (en el caso de que la entrada consista solo en uno de esos valores). ), o el min / max correcto será encontrado.

Cabe señalar que los tipos primitivos deben tener un valor. Si usó Objetos (es decir, Integer ), podría inicializar el valor a null y manejar ese caso especial para la primera comparación, pero eso crea un código adicional (innecesario). Sin embargo, al usar estos valores, el código de bucle no necesita preocuparse por el caso de borde de la primera comparación.

Otra alternativa es establecer los valores iniciales en el primer valor de la matriz de entrada (nunca es un problema, ver más abajo) e iterar desde el segundo elemento en adelante, ya que este es el único estado correcto de mín / máx después de una iteración. También podría repetir desde el primer elemento: no haría ninguna diferencia, aparte de realizar una iteración adicional (innecesaria) sobre el primer elemento.

La única forma sensata de lidiar con la entrada de tamaño cero es simple: lanzar una IllegalArgumentException , porque min / max no está definido en este caso.

Answer 3

En lugar de inicializar las variables con valores arbitrarios (por ejemplo, int smallest = 9999, largest = 0 ) es más seguro inicializar las variables con los valores más grandes y más pequeños representables por ese tipo de número (que es int smallest = Integer.MAX_VALUE, largest = Integer.MIN_VALUE ).

Ya que su matriz de enteros no puede contener un valor mayor que Integer.MAX_VALUE y más pequeño que Integer.MIN_VALUE su código funciona en todos los casos de borde.