Mayores y menores de un conjunto de números en Java

Más ejercicios resueltos

Si deseas revisar más ejercicios resueltos, haz click en el siguiente botón. 

A continuación presentamos 2 alternativas de solución al problema de encontrar los mayores y menores números en un conjunto de números naturales en Java. Si deseas ver el enunciado del problema, haz click en el siguiente enlace. Si deseas entender el diseño algorítmico detrás de las soluciones presentadas, le invitamos a visitar el siguiente enlace.

Lectura de un número

La lectura de datos en Java la realizaremos con la clase \texttt{Scanner}. Instanciamos el objeto  \texttt{reader} de dicha clase y procedemos a la lectura. Usaremos la variable \texttt{n} para leer el valor de un número del conjunto que se solicitará. Para leer el valor en la variable \texttt{n} usaremos el método \texttt{nextInt}.

package mayores_menores_v1_1;

import java.util.Scanner;

public class Mayores_Menores_v1_1 {

    public static void main(String[] args) {        
        int n;
        
        System.out.printf("Ingrese número: ");
        n = reader.nextInt();        
    }
} 

Control de flujo para la lectura de varios números

Para leer el conjunto de números usaremos una estructura iterativa con salida controlada. En Java se implementa mediante la instrucción \texttt{do-while}. Se utilizará un control por centinela usando la condición \texttt{n>=0}. Esto hará que se repita la iteración mientras el valor de \texttt{n} sea mayor o igual que cero.

Noten en el fragmento de código siguiente que la lectura de datos se ha colocado dentro de la iteración. Esto es importante hacerlo pues sino no podríamos leer varios números. Además, dentro de la iteración se ha colocado una selectiva simple para filtrar valores válidos y dejar de lado al centinela. Esto pues el centinela será leído y verificado en la salida. 

package mayores_menores_v1_1;

import java.util.Scanner;

public class Mayores_Menores_v1_1 {

    public static void main(String[] args) {        
        int n;
        Scanner reader = new Scanner(System.in);
        do {
            System.out.printf("Ingrese número: ");
            n = reader.nextInt();

            if (n >= 0) {                
                
            }
        } while (n >= 0);        
    }
} 

Numeración de los números leídos

Dado que uno de los algoritmos a usar se basa en la identificación del primer número leído, vamos a proceder a identificarlos. Usaremos la variable \texttt{i} para dicho fin. Inicializamos la variable \texttt{i} con el valor de \texttt{0} y la incrementaremos apenas se verifique que el valor leído es un número «válido», es decir no es un centinela. Para el incremento usamos la operación de incremento \texttt{++}. \texttt{i++} equivale a \texttt{i=i+1}.

package mayores_menores_v1_1;

import java.util.Scanner;

public class Mayores_Menores_v1_1 {

    public static void main(String[] args) {        
        int n, i = 0;
        Scanner reader = new Scanner(System.in);
        do {
            System.out.printf("Ingrese número %d: ", i + 1);
            n = reader.nextInt();

            if (n >= 0) {
                i++;
                
            }
        } while (n >= 0);        
    }
} 

Inicialización del mayor

El valor del número con mayor valor lo almacenaremos en la variable \texttt{mayor\_magnitud}. El valor inicial que le asignaremos a esta variable será el primer número leído. Para esto usamos la variable \texttt{i} descrita previamente en la condición de una selectiva doble. Para saber si es el primer número usaremos la condición \texttt{i==1}.

package mayores_menores_v1_1;

import java.util.Scanner;

public class Mayores_Menores_v1_1 {

    public static void main(String[] args) {        
        int n, i = 0, mayor_magnitud=0;
        Scanner reader = new Scanner(System.in);
        do {
            System.out.printf("Ingrese número %d: ", i + 1);
            n = reader.nextInt();

            if (n >= 0) {
                i++;
                if (i == 1) {
                    mayor_magnitud = n;
                } else {
                                        
                }
            }
        } while (n >= 0);        
    }
} 

Actualización del mayor

En este paso realizaremos la actualización de la variable \texttt{mayor\_magnitud}. La actualizamos con el valor de \texttt{n} si es que se cumple que \texttt{n>mayor\_magnitud}. Esta operación es excluyente con la inicialización. La inicialización se hace cuando se lee el primer número, la actualización se evalúa desde el segundo número en adelante.

package mayores_menores_v1_1; 

import java.util.Scanner;

public class Mayores_Menores_v1_1 {

    public static void main(String[] args) {        
        int n, i = 0, mayor_magnitud=0;
        Scanner reader = new Scanner(System.in);
        do {
            System.out.printf("Ingrese número %d: ", i + 1);
            n = reader.nextInt();

            if (n >= 0) {
                i++;
                if (i == 1) {
                    mayor_magnitud = n;
                } else {
                    if (n > mayor_magnitud) {
                        mayor_magnitud = n;
                    }                    
                }
            }
        } while (n >= 0);        
    }
} 

Inicialización del menor

El valor del número con menor valor lo almacenaremos en la variable \texttt{menor\_magnitud}. El valor inicial que le asignaremos a esta variable será el primer número leído. En este caso en particular, hemos usado la asignación múltiple. Esto permite asignar un mismo valor a varias variables en una sola instrucción. La instrucción \texttt{mayor\_magnitud = menor\_magnitud = n}, asigna el valor de la varible \texttt{n} tanto a \texttt{mayor\_magnitud} como a \texttt{menor\_magnitud}.

package mayores_menores_v1_1;

import java.util.Scanner;

public class Mayores_Menores_v1_1 {

    public static void main(String[] args) {        
        int n, i = 0, mayor_magnitud=0, menor_magnitud=0;
        Scanner reader = new Scanner(System.in);
        do {
            System.out.printf("Ingrese número %d: ", i + 1);
            n = reader.nextInt();

            if (n >= 0) {
                i++;
                if (i == 1) {
                    mayor_magnitud = menor_magnitud = n;
                } else {
                    if (n > mayor_magnitud) {
                        mayor_magnitud = n;
                    }                    
                }
            }
        } while (n >= 0);        
    }
} 

Actualización del menor

Ahora procederemos a realizar la actualización de la variable \texttt{menor\_magnitud}. La actualizamos con el valor de \texttt{n} si es que se cumple que \texttt{n<menor\_magnitud}. Para esto usamos otra selectiva simple.

package mayores_menores_v1_1;

import java.util.Scanner;

public class Mayores_Menores_v1_1 {

    public static void main(String[] args) {        
        int n, i = 0, mayor_magnitud=0, menor_magnitud=0;
        Scanner reader = new Scanner(System.in);
        do {
            System.out.printf("Ingrese número %d: ", i + 1);
            n = reader.nextInt();

            if (n >= 0) {
                i++;
                if (i == 1) {
                    mayor_magnitud = menor_magnitud = n;
                } else {
                    if (n > mayor_magnitud) {
                        mayor_magnitud = n;
                    }
                    if (n < menor_magnitud) {
                        menor_magnitud = n;
                    }
                }
            }
        } while (n >= 0);        
    }
} 

Verificación de ingreso de números

Antes de realizar la impresión de los resultados encontrados, debemos verificar si el usuario ha ingresado números. Para esto nos valemos nuevamente de la variable \texttt{i}. Si \texttt{i} contiene el valor de \texttt{0}, significa que no se han leído números «válidos».

package mayores_menores_v1_1;

import java.util.Scanner;

public class Mayores_Menores_v1_1 {

    public static void main(String[] args) {        
        int n, i = 0, mayor_magnitud=0, menor_magnitud=0;
        Scanner reader = new Scanner(System.in);
        do {
            System.out.printf("Ingrese número %d: ", i + 1);
            n = reader.nextInt();

            if (n >= 0) {
                i++;
                if (i == 1) {
                    mayor_magnitud = menor_magnitud = n;
                } else {
                    if (n > mayor_magnitud) {
                        mayor_magnitud = n;
                    }
                    if (n < menor_magnitud) {
                        menor_magnitud = n;
                    }
                }
            }
        } while (n >= 0);
        if (i == 0) {
            System.out.printf("No se ha ingresado ningún número%n");
        } else {
            
        }
    }
} 

Impresión del mayor y del menor

Finalmente se procede a la impresión de los valores hallados. Esto lo haremos si y solo si, la variable \texttt{i} es mayor que cero.

package mayores_menores_v1_1;

import java.util.Scanner;

public class Mayores_Menores_v1_1 {

    public static void main(String[] args) {        
        int n, i = 0, mayor_magnitud=0, menor_magnitud=0;
        Scanner reader = new Scanner(System.in);
        do {
            System.out.printf("Ingrese número %d: ", i + 1);
            n = reader.nextInt();

            if (n >= 0) {
                i++;
                if (i == 1) {
                    mayor_magnitud = menor_magnitud = n;
                } else {
                    if (n > mayor_magnitud) {
                        mayor_magnitud = n;
                    }
                    if (n < menor_magnitud) {
                        menor_magnitud = n;
                    }
                }
            }
        } while (n >= 0);
        if (i == 0) {
            System.out.printf("No se ha ingresado ningún número%n");
        } else {
            System.out.printf("El número con mayor magnitud es: %d%n", mayor_magnitud);
            System.out.printf("El número con menor magnitud es: %d%n", menor_magnitud);
        }
    }
} 

Versión usando break

Cuando utilizamos un ciclo iterativo controlado por un centinela, comúnmente se suele utilizar la instrucción de ruptura de ciclo \texttt{break} para facilitar la lectura del código. 

¿Qué cambios se han realizado? Bueno, en lugar de colocar todo el código dentro de un bloque de una selectiva simple, este se coloca fuera del \texttt{if}. Se usa la selectiva simple para romper el flujo haciendo un \texttt{break}. El \texttt{break} hace que la instrucción iterativa termine. Esta será la forma de salir de la iteración, cuando \texttt{n<0}, se ejecuta el \texttt{break}. Además, dado que solo se saldrá por la ruptura del ciclo, deja de tener relevancia la condición de la iterativa, por este motivo dejamos el control en la salida como \texttt{while (true)}. Es decir, un ciclo infinito.

¿Te parece más fácil de leer esta versión? o ¿crees que la versión anterior es más fácil de entender?

package mayores_menores_v1_2;

import java.util.Scanner;

public class Mayores_Menores_v1_2 {

    public static void main(String[] args) {
        int n, i = 0, mayor_magnitud = 0, menor_magnitud = 0;
        Scanner reader = new Scanner(System.in);
        do {
            System.out.printf("Ingrese número %d: ", i + 1);
            n = reader.nextInt();

            if (n < 0) {
                break;
            }
            i++;
            if (i == 1) {
                mayor_magnitud = menor_magnitud = n;
            } else {
                if (n > mayor_magnitud) {
                    mayor_magnitud = n;
                }
                if (n < menor_magnitud) {
                    menor_magnitud = n;
                }
            }
        } while (true);
        if (i == 0) {
            System.out.printf("No se ha ingresado ningún número%n");
        } else {
            System.out.printf("El número con mayor magnitud es: %d%n", mayor_magnitud);
            System.out.printf("El número con menor magnitud es: %d%n", menor_magnitud);
        }
    }
} 

Versión inicializando máximos y mínimos

Veremos ahora otra versión del mismo algoritmo. En la versión presentada anteriormente, las variables \texttt{mayor\_magnitud} y \texttt{menor\_magnitud} han sido inicializadas con el primer número leído. En la versión que presentamos en esta sección hemos realizado un cambio en la inicialización. Se está inicializando las variables \texttt{mayor\_magnitud} y \texttt{menor\_magnitud} antes de realizar la iteración.

¿Con qué valor inicializamos estas variables?  \texttt{mayor\_magnitud} vamos a inicializarlo con el menor entero posible, mientras que \texttt{menor\_magnitud} vamos a inicializarlo con el mayor entero posible. De esta forma se garantiza que cuando se haga la comparación, en la primera iteración se tendrá el valor requerido. 

En Java, el menor valor entero posible lo obtenemos con la constante \texttt{MIN\_VALUE}. El mayor entero posible lo obtenemos con la constante \texttt{MAX\_VALUE}.  Ambas constantes se encuentran definidas en la clase \texttt{Integer}.

package mayores_menores_v1_3;

import java.util.Scanner;

public class Mayores_Menores_v1_3 {

    public static void main(String[] args) {
        int n, i = 0;
        int mayor_magnitud = Integer.MIN_VALUE;
        int menor_magnitud = Integer.MAX_VALUE;
        Scanner reader = new Scanner(System.in);
        do {
            System.out.printf("Ingrese número %d: ", i + 1);
            n = reader.nextInt();

            if (n < 0) {
                break;
            }
            i++;
            if (n > mayor_magnitud) {
                mayor_magnitud = n;
            }
            if (n ﹤ menor_magnitud) {
                menor_magnitud = n;
            }
        } while (true);
        if (i == 0) {
            System.out.printf("No se ha ingresado ningún número%n");
        } else {
            System.out.printf("El número con mayor magnitud es: %d%n", mayor_magnitud);
            System.out.printf("El número con menor magnitud es: %d%n", menor_magnitud);
        }
    }
} 

Resolución de problemas: caso dos mayores y dos menores

Control de flujo para la lectura de varios números

Procederemos ahora a resolver a encontrar los dos mayores y los dos menores números de la lista. Iniciamos con el control de flujo para la lectura de varios números. Esta parte es exactamente igual al caso anterior.

package mayores_menores_v2_1;

import java.util.Scanner;

public class Mayores_Menores_v2_1 {

    public static void main(String[] args) {
        int n;        
        Scanner reader = new Scanner(System.in);
        do {
            System.out.printf("Ingrese número: ");
            n = reader.nextInt();

            if (n < 0) {
                break;
            }            
            
        } while (true);        
    }
} 

Numeración de los números leídos

La numeración de los números leídos sigue la misma lógica presentada en el ejercicio anterior. Seguiremos usando la variable \texttt{i} para lograr dicho objetivo.

package mayores_menores_v2_1;

import java.util.Scanner;

public class Mayores_Menores_v2_1 {

    public static void main(String[] args) {
        int n, i = 0;        
        Scanner reader = new Scanner(System.in);
        do {
            System.out.printf("Ingrese número %d: ", i + 1);
            n = reader.nextInt();

            if (n < 0) {
                break;
            }
            i++;
            
        } while (true);        
    }
} 

Inicialización del primer mayor

Procederemos ahora con la inicialización de las variables. La lógica a usar será similar al caso anterior con la diferencia que ahora tendremos dos variables, una para el número con mayor magnitud y otra para el segundo número con mayor magnitud. 

Usaremos la variable \texttt{mayor\_magnitud1} para almacenar el mayor número de todos los de la lista. Inicializamos este variable con el primer número leído. Como hicimos en el programa anterior, usamos una instrucción selectiva verificando la condición \texttt{i=1}.

package mayores_menores_v2_1;

import java.util.Scanner;

public class Mayores_Menores_v2_1 {

    public static void main(String[] args) {
        int n, i = 0, mayor_magnitud1;
        mayor_magnitud1 = 0;
        Scanner reader = new Scanner(System.in);
        do {
            System.out.printf("Ingrese número %d: ", i + 1);
            n = reader.nextInt();

            if (n < 0) {
                break;
            }
            i++;
            if (i == 1) {
                mayor_magnitud1 = n;
            } else {
                
            }
        } while (true);        
    }
} 

Inicialización del segundo mayor

Procederemos ahora a inicializar el segundo mayor. Usaremos la variable \texttt{mayor\_magnitud2} para almacenar el segundo mayor número de todos los de la lista.

La inicialización no es tan sencilla como en el caso del primer mayor porque pueden existir dos situaciones:

  1.  Que el segundo número sea mayor que el primero leído. En este caso, la variable \texttt{mayor\_magnitud2} se inicializa con el valor de \texttt{mayor\_magnitud1} pues por la condición antes descrita este es el segundo mayor. La variable \texttt{mayor\_magnitud1} se actualiza con el valor del número \texttt{n} que se acaba de leer para que siempre contenga el mayor de todos. 
  2. Que el segundo número sea menor o igual que el primero leído. Este caso es más simple de tratar, basta con inicializar \texttt{mayor\_magnitud2} con el valor de \texttt{n}. Es el segundo número y si no es mayor que el primero, entonces no queda otra que sea el segundo mayor.
package mayores_menores_v2_1;

import java.util.Scanner;

public class Mayores_Menores_v2_1 {

    public static void main(String[] args) {
        int n, i = 0, mayor_magnitud1, mayor_magnitud2;
        mayor_magnitud1 = mayor_magnitud2 = 0;
        Scanner reader = new Scanner(System.in);
        do {
            System.out.printf("Ingrese número %d: ", i + 1);
            n = reader.nextInt();

            if (n < 0) {
                break;
            }
            i++;
            if (i == 1) {
                mayor_magnitud1 = n;
            } else {
                if (i == 2) {
                    if (n > mayor_magnitud1) {
                        mayor_magnitud2 = mayor_magnitud1;
                        mayor_magnitud1 = n;
                    } else {
                        mayor_magnitud2 = n;
                    }
                }
            }
        } while (true);        
    }
} 

Actualización de mayores

Procedemos ahora a mantener actualizados los dos mayores conforme se vayan leyendo los números. A partir del tercer número leído en adelante, verificamos si el número leído es mayor que alguno de los anteriores para proceder con la respectiva actualización. Deberemos hacer una actualización si es que el número leído \texttt{n} es mayor que los dos mayores conocidos. Para esto usamos la condición \texttt{n>mayor\_magnitud1\ ||\ n>mayor\_magnitud2}. Si esta condición se cumple, deberemos actualizar una o las dos variables.

Si el valor leído es mayor que \texttt{mayor\_magnitud1}, en este caso debemos actualizar \texttt{mayor\_magnitud2} con el valor de \texttt{mayor\_magnitud1} y \texttt{mayor\_magnitud1} con el valor de \texttt{n}. Si el valor leído solo es mayor que \texttt{mayor\_magnitud2}, en este caso debemos actualizar únicamente \texttt{mayor\_magnitud2} con \texttt{n}.

La lógica a usar en esta actualización es la misma usada que en la inicialización del segundo mayor, por lo que la lógica descrita anteriormente se puede expresar como sigue:

package mayores_menores_v2_1;

import java.util.Scanner;

public class Mayores_Menores_v2_1 {

    public static void main(String[] args) {
        int n, i = 0, mayor_magnitud1, mayor_magnitud2;
        mayor_magnitud1 = mayor_magnitud2 = 0;
        Scanner reader = new Scanner(System.in);
        do {
            System.out.printf("Ingrese número %d: ", i + 1);
            n = reader.nextInt();

            if (n < 0) {
                break;
            }
            i++;
            if (i == 1) {
                mayor_magnitud1 = n;
            } else {
                if (i == 2 || n > mayor_magnitud1 || n > mayor_magnitud2) {
                    if (n > mayor_magnitud1) {
                        mayor_magnitud2 = mayor_magnitud1;
                        mayor_magnitud1 = n;
                    } else {
                        mayor_magnitud2 = n;
                    }
                }
            }
        } while (true);        
    }
} 

Inicialización del primer menor

El valor del número con menor valor lo almacenaremos en la variable \texttt{menor\_magnitud1}. El valor inicial que le asignaremos a esta variable será el primer número leído. En este caso en particular, hemos usado nuevamente la asignación múltiple

package mayores_menores_v2_1;

import java.util.Scanner;

public class Mayores_Menores_v2_1 {

    public static void main(String[] args) {
        int n, i = 0, mayor_magnitud1, mayor_magnitud2, menor_magnitud1;
        mayor_magnitud1 = mayor_magnitud2 = menor_magnitud1 = 0;
        Scanner reader = new Scanner(System.in);
        do {
            System.out.printf("Ingrese número %d: ", i + 1);
            n = reader.nextInt();

            if (n < 0) {
                break;
            }
            i++;
            if (i == 1) {
                mayor_magnitud1 = menor_magnitud1 = n;
            } else {
                if (i == 2 || n > mayor_magnitud1 || n > mayor_magnitud2) {
                    if (n > mayor_magnitud1) {
                        mayor_magnitud2 = mayor_magnitud1;
                        mayor_magnitud1 = n;
                    } else {
                        mayor_magnitud2 = n;
                    }
                }
            }
        } while (true);        
    }
} 

Inicialización del segundo menor

Procederemos ahora a inicializar el segundo menor. Usaremos la variable \texttt{menor\_magnitud2} para almacenar el segundo menor número de todos los de la lista.

La inicialización no es tan sencilla como en el caso del primer mayor porque pueden existir dos situaciones:

  1.  Que el segundo número sea menor que el primero leído. En este caso, la variable \texttt{menor\_magnitud2} se inicializa con el valor de \texttt{menor\_magnitud1} pues por la condición antes descrita este es el segundo mayor. La variable \texttt{menor\_magnitud1} se actualiza con el valor del número \texttt{n} que se acaba de leer para que siempre contenga el mayor de todos. 
  2. Que el segundo número sea mayor o igual que el primero leído. Este caso es más simple de tratar, basta con inicializar \texttt{menor\_magnitud2} con el valor de \texttt{n}. Es el segundo número y si no es menor que el primero, entonces no queda otra que sea el segundo mayor.
package mayores_menores_v2_1;

import java.util.Scanner;

public class Mayores_Menores_v2_1 {

    public static void main(String[] args) {
        int n, i = 0, mayor_magnitud1, mayor_magnitud2, menor_magnitud1, menor_magnitud2;
        mayor_magnitud1 = mayor_magnitud2 = menor_magnitud1 = menor_magnitud2 = 0;
        Scanner reader = new Scanner(System.in);
        do {
            System.out.printf("Ingrese número %d: ", i + 1);
            n = reader.nextInt();

            if (n < 0) {
                break;
            }
            i++;
            if (i == 1) {
                mayor_magnitud1 = menor_magnitud1 = n;
            } else {
                if (i == 2 || n > mayor_magnitud1 || n > mayor_magnitud2) {
                    if (n > mayor_magnitud1) {
                        mayor_magnitud2 = mayor_magnitud1;
                        mayor_magnitud1 = n;
                    } else {
                        mayor_magnitud2 = n;
                    }
                }
                if (i == 2) {
                    if (n < menor_magnitud1) {
                        menor_magnitud2 = menor_magnitud1;
                        menor_magnitud1 = n;
                    } else {
                        menor_magnitud2 = n;
                    }
                }
            }
        } while (true);        
    }
} 

Actualización de menores

Procedemos ahora a mantener actualizados los dos menores conforme se vayan leyendo los números. A partir del tercer número leído en adelante, verificamos si el número leído es menor que alguno de los anteriores para proceder con la respectiva actualización. Deberemos hacer una actualización si es que el número leído \texttt{n} es menor que los dos menores conocidos. Para esto usamos la condición \texttt{n<menor\_magnitud1\ ||\ n<menor\_magnitud2}. Si esta condición se cumple, deberemos actualizar una o las dos variables.

Si el valor leído es menor que \texttt{menor\_magnitud1}, en este caso debemos actualizar \texttt{menor\_magnitud2} con el valor de \texttt{menor\_magnitud1} y \texttt{menor\_magnitud1} con el valor de \texttt{n}. Si el valor leído solo es mayor que \texttt{menor\_magnitud2}, en este caso debemos actualizar únicamente \texttt{menor\_magnitud2} con \texttt{n}.

La lógica a usar en esta actualización es la misma usada que en la inicialización del segundo menor, por lo que la lógica descrita anteriormente se puede expresar como sigue:

package mayores_menores_v2_1;

import java.util.Scanner;

public class Mayores_Menores_v2_1 {

    public static void main(String[] args) {
        int n, i = 0, mayor_magnitud1, mayor_magnitud2, menor_magnitud1, menor_magnitud2;
        mayor_magnitud1 = mayor_magnitud2 = menor_magnitud1 = menor_magnitud2 = 0;
        Scanner reader = new Scanner(System.in);
        do {
            System.out.printf("Ingrese número %d: ", i + 1);
            n = reader.nextInt();

            if (n < 0) {
                break;
            }
            i++;
            if (i == 1) {
                mayor_magnitud1 = menor_magnitud1 = n;
            } else {
                if (i == 2 || n > mayor_magnitud1 || n > mayor_magnitud2) {
                    if (n > mayor_magnitud1) {
                        mayor_magnitud2 = mayor_magnitud1;
                        mayor_magnitud1 = n;
                    } else {
                        mayor_magnitud2 = n;
                    }
                }
                if (i == 2 || n < menor_magnitud1 || n < menor_magnitud2) {
                    if (n < menor_magnitud1) {
                        menor_magnitud2 = menor_magnitud1;
                        menor_magnitud1 = n;
                    } else {
                        menor_magnitud2 = n;
                    }
                }
            }
        } while (true);        
    }
} 

Verificación de ingreso de números

Antes de realizar la impresión de los resultados encontrados, debemos verificar si el usuario ha ingresado números. Para esto nos valemos nuevamente de la variable \texttt{i}. Si \texttt{i} contiene el valor de \texttt{0}, significa que no se han leído números «válidos».

package mayores_menores_v2_1;

import java.util.Scanner;

public class Mayores_Menores_v2_1 {

    public static void main(String[] args) {
        int n, i = 0, mayor_magnitud1, mayor_magnitud2, menor_magnitud1, menor_magnitud2;
        mayor_magnitud1 = mayor_magnitud2 = menor_magnitud1 = menor_magnitud2 = 0;
        Scanner reader = new Scanner(System.in);
        do {
            System.out.printf("Ingrese número %d: ", i + 1);
            n = reader.nextInt();

            if (n < 0) {
                break;
            }
            i++;
            if (i == 1) {
                mayor_magnitud1 = menor_magnitud1 = n;
            } else {
                if (i == 2 || n > mayor_magnitud1 || n > mayor_magnitud2) {
                    if (n > mayor_magnitud1) {
                        mayor_magnitud2 = mayor_magnitud1;
                        mayor_magnitud1 = n;
                    } else {
                        mayor_magnitud2 = n;
                    }
                }
                if (i == 2 || n < menor_magnitud1 || n < menor_magnitud2) {
                    if (n < menor_magnitud1) {
                        menor_magnitud2 = menor_magnitud1;
                        menor_magnitud1 = n;
                    } else {
                        menor_magnitud2 = n;
                    }
                }
            }
        } while (true);
        if (i == 0) {
            System.out.printf("No se ha ingresado ningún número%n");
        } else {
            
        }
    }
} 

Impresión de los mayores y de los menores

Finalmente se procede a la impresión de los valores hallados. Esto lo haremos si y solo si, la variable \texttt{i} es mayor que cero. Pero a diferencia del ejercicio anterior, puede darse el caso que existe un solo mayor o un solo menor. Esto se va dar cuando el usuario ha ingresado un único valor.

Por este motivo, antes de imprimir el segundo mayor o el segundo menor, debemos de verificar si es que se han leído por lo menos dos número. Esto lo verificamos fácilmente con la condición \texttt{i>=2}.

package mayores_menores_v2_1;

import java.util.Scanner;

public class Mayores_Menores_v2_1 {

    public static void main(String[] args) {
        int n, i = 0, mayor_magnitud1, mayor_magnitud2, menor_magnitud1, menor_magnitud2;
        mayor_magnitud1 = mayor_magnitud2 = menor_magnitud1 = menor_magnitud2 = 0;
        Scanner reader = new Scanner(System.in);
        do {
            System.out.printf("Ingrese número %d: ", i + 1);
            n = reader.nextInt();

            if (n < 0) {
                break;
            }
            i++;
            if (i == 1) {
                mayor_magnitud1 = menor_magnitud1 = n;
            } else {
                if (i == 2 || n > mayor_magnitud1 || n > mayor_magnitud2) {
                    if (n > mayor_magnitud1) {
                        mayor_magnitud2 = mayor_magnitud1;
                        mayor_magnitud1 = n;
                    } else {
                        mayor_magnitud2 = n;
                    }
                }
                if (i == 2 || n < menor_magnitud1 || n < menor_magnitud2) {
                    if (n < menor_magnitud1) {
                        menor_magnitud2 = menor_magnitud1;
                        menor_magnitud1 = n;
                    } else {
                        menor_magnitud2 = n;
                    }
                }
            }
        } while (true);
        if (i == 0) {
            System.out.printf("No se ha ingresado ningún número%n");
        } else {
            System.out.printf("El 1er número con mayor magnitud es: %d%n", mayor_magnitud1);
            if (i > 1) {
                System.out.printf("El 2do número con mayor magnitud es: %d%n", mayor_magnitud2);
            }
            System.out.printf("El 1er número con menor magnitud es: %d%n", menor_magnitud1);
            if (i > 1) {
                System.out.printf("El 2do número con menor magnitud es: %d%n", menor_magnitud2);
            }
        }
    }
} 

Versión inicializando máximos y mínimos

Este problema también se puede resolver inicializando las variables de los mayores y menores con los valores mínimos y máximos respectivamente. Recuerde que en Java, el menor valor entero posible lo obtenemos con la constante \texttt{MIN\_VALUE}. El mayor entero posible lo obtenemos con la constante \texttt{MAX\_VALUE}.  Ambas constantes se encuentran definidas en la clase \texttt{Integer}.

package mayores_menores_v2_2;

import java.util.Scanner;

public class Mayores_Menores_v2_2 {

    public static void main(String[] args) {
        int n, i = 0, mayor_magnitud1, mayor_magnitud2, menor_magnitud1, menor_magnitud2;
        mayor_magnitud1 = mayor_magnitud2 = Integer.MIN_VALUE;
        menor_magnitud1 = menor_magnitud2 = Integer.MAX_VALUE;
        Scanner reader = new Scanner(System.in);
        do {
            System.out.printf("Ingrese número %d: ", i + 1);
            n = reader.nextInt();

            if (n < 0) {
                break;
            }
            i++;
            if (n > mayor_magnitud1 || n > mayor_magnitud2) {
                if (n > mayor_magnitud1) {
                    mayor_magnitud2 = mayor_magnitud1;
                    mayor_magnitud1 = n;
                } else {
                    mayor_magnitud2 = n;
                }
            }
            if (n < menor_magnitud1 || n < menor_magnitud2) {
                if (n < menor_magnitud1) {
                    menor_magnitud2 = menor_magnitud1;
                    menor_magnitud1 = n;
                } else {
                    menor_magnitud2 = n;
                }
            }
        } while (true);
        if (i == 0) {
            System.out.printf("No se ha ingresado ningún número%n");
        } else {
            System.out.printf("El 1er número con mayor magnitud es: %d%n", mayor_magnitud1);
            if (i > 1) {
                System.out.printf("El 2do número con mayor magnitud es: %d%n", mayor_magnitud2);
            }
            System.out.printf("El 1er número con menor magnitud es: %d%n", menor_magnitud1);
            if (i > 1) {
                System.out.printf("El 2do número con menor magnitud es: %d%n", menor_magnitud2);
            }
        }
    }
} 

Conclusión

Hemos presentado en este artículo, propuestas de solución para la determinación de los mayores y menores números de un conjunto de números naturales. Se ha utilizado para el control de flujo la estructura iterativa y muchas decisiones usando estructuras selectivas. Podrá descargar la solución propuesta en el repositorio GitHub de iterando++ a través del siguiente enlace

Hemos preparado otros artículos adicionales en donde describimos al detalle la implementación de este problema en PSeInt y otros lenguajes de programación. Te invitamos a leer los siguientes artículos de iterando++

Si te interesa profundizar en Java, el mejor libro que hay es Effective Java de Joshua Bloch. Uno de los libros favoritos de los que se inician en Java es Java: Learn Java in One Day and Learn It Well de  Jamie Chan.

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *