Cómo comprobar si una matriz (array) está ordenada en Java

Introducción

En este laboratorio, aprenderás cómo comprobar si una matriz (array) de números está ordenada en Java. Exploraremos el concepto fundamental de comparar elementos adyacentes, que es una idea central en muchos algoritmos de clasificación (sorting). Aprenderás cómo comprobar tanto el orden ascendente como el descendente, y cómo manejar casos en los que los elementos son iguales. Al final de este laboratorio, tendrás una comprensión sólida de la lógica necesaria para determinar si una matriz está ordenada.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL java(("Java")) -.-> java/BasicSyntaxGroup(["Basic Syntax"]) java(("Java")) -.-> java/DataStructuresGroup(["Data Structures"]) java/BasicSyntaxGroup -.-> java/operators("Operators") java/BasicSyntaxGroup -.-> java/if_else("If...Else") java/DataStructuresGroup -.-> java/sorting("Sorting") subgraph Lab Skills java/operators -.-> lab-560004{{"Cómo comprobar si una matriz (array) está ordenada en Java"}} java/if_else -.-> lab-560004{{"Cómo comprobar si una matriz (array) está ordenada en Java"}} java/sorting -.-> lab-560004{{"Cómo comprobar si una matriz (array) está ordenada en Java"}} end

Comparar elementos adyacentes para la clasificación

En este paso, comenzaremos a explorar el concepto fundamental de comparar elementos adyacentes, que es una idea central en muchos algoritmos de clasificación (sorting). La clasificación es el proceso de organizar elementos en un orden específico, como ascendente o descendente.

Imagina que tienes una lista de números y quieres ordenarlos de menor a mayor. Una forma sencilla de comenzar es mirar dos números que estén uno al lado del otro y decidir cuál debe ir primero.

Vamos a crear un sencillo programa en Java para demostrar esta idea. Crearemos una clase que compare dos números.

Abre el archivo HelloJava.java en el editor WebIDE si todavía está abierto. Modificaremos este archivo para nuestro nuevo programa.
Reemplaza todo el contenido del archivo con el siguiente código:
```
public class CompareNumbers {
    public static void main(String[] args) {
        int number1 = 15;
        int number2 = 10;

        System.out.println("Comparing " + number1 + " and " + number2 + ":");

        if (number1 > number2) {
            System.out.println(number1 + " is greater than " + number2);
        } else if (number1 < number2) {
            System.out.println(number1 + " is less than " + number2);
        } else {
            System.out.println(number1 + " is equal to " + number2);
        }
    }
}
```
Veamos las nuevas partes de este código:
- public class CompareNumbers: Hemos cambiado el nombre de la clase a CompareNumbers para reflejar mejor lo que hace el programa. Recuerda, el nombre del archivo debe coincidir con el nombre de la clase, así que tendremos que renombrar el archivo más tarde.
- int number1 = 15; y int number2 = 10;: Estas líneas declaran dos variables enteras, number1 y number2, y les asignan valores iniciales.
- System.out.println("Comparing " + number1 + " and " + number2 + ":");: Esta línea imprime un mensaje que indica qué números se están comparando.
- if (number1 > number2): Esta es una declaración if. Comprueba si la condición dentro de los paréntesis (number1 > number2) es verdadera. Si lo es, se ejecuta el código dentro de las llaves {} que siguen inmediatamente a la declaración if.
- else if (number1 < number2): Esta es una declaración else if. Si la condición en la declaración if era falsa, se comprueba esta condición (number1 < number2). Si es verdadera, se ejecuta el código dentro de sus llaves.
- else: Esta es una declaración else. Si ninguna de las condiciones if ni else if era verdadera, se ejecuta el código dentro del bloque else.
- System.out.println(...): Estas líneas imprimen mensajes basados en el resultado de la comparación.
Guarda el archivo (Ctrl+S o Cmd+S).
Ahora, necesitamos renombrar el archivo para que coincida con el nuevo nombre de la clase. En la Terminal, asegúrate de estar en el directorio ~/project:
```
cd ~/project
```
Renombra el archivo usando el comando mv:
```
mv HelloJava.java CompareNumbers.java
```
Este comando mueve (renombra) el archivo HelloJava.java a CompareNumbers.java.
Ahora, compila el nuevo programa:
```
javac CompareNumbers.java
```
Si la compilación es exitosa, no deberías ver ninguna salida.
Finalmente, ejecuta el programa compilado:
```
java CompareNumbers
```
Deberías ver la salida que indica el resultado de la comparación:
```
Comparing 15 and 10:
15 is greater than 10
```

Has creado y ejecutado con éxito un programa en Java que compara dos elementos adyacentes e imprime el resultado. Esta simple comparación es un bloque de construcción para algoritmos de clasificación más complejos.

Comprobar el orden ascendente y descendente

En el paso anterior, aprendimos cómo comparar dos números. Ahora, expandamos eso para comprobar si un par de números adyacentes está en orden ascendente o descendente. Este es otro concepto fundamental cuando se piensa en la clasificación (sorting).

El orden ascendente significa organizar los elementos de menor a mayor (por ejemplo, 1, 5, 10). El orden descendente significa organizar los elementos de mayor a menor (por ejemplo, 10, 5, 1).

Modificaremos nuestro programa CompareNumbers.java para comprobar estos ordenamientos específicos.

Abre el archivo CompareNumbers.java en el editor WebIDE.

Reemplaza el código existente con el siguiente:

public class CheckOrder {
    public static void main(String[] args) {
        int number1 = 15;
        int number2 = 10;

        System.out.println("Checking order of " + number1 + " and " + number2 + ":");

        if (number1 < number2) {
            System.out.println("The numbers are in ascending order.");
        } else if (number1 > number2) {
            System.out.println("The numbers are in descending order.");
        } else {
            System.out.println("The numbers are equal.");
        }
    }
}

Esto es lo que hemos cambiado:

public class CheckOrder: Hemos cambiado el nombre de la clase a CheckOrder. Tendremos que renombrar el archivo para que coincida.
La condición if ahora comprueba si number1 es menor que number2. Si es verdadero, significa que están en orden ascendente.
La condición else if comprueba si number1 es mayor que number2. Si es verdadero, están en orden descendente.
El bloque else maneja el caso en el que los números son iguales.

Guarda el archivo (Ctrl+S o Cmd+S).
En la Terminal, asegúrate de estar en el directorio ~/project:
```
cd ~/project
```
Renombra el archivo para que coincida con el nuevo nombre de la clase:
```
mv CompareNumbers.java CheckOrder.java
```
Compila el programa modificado:
```
javac CheckOrder.java
```
Nuevamente, la ausencia de salida significa que la compilación fue exitosa.

Ejecuta el programa:

java CheckOrder

Con number1 = 15 y number2 = 10, la salida debería ser:

Checking order of 15 and 10:
The numbers are in descending order.

Modifiquemos rápidamente los números para ver el caso de orden ascendente. Abre CheckOrder.java en el editor y cambia los valores:

public class CheckOrder {
    public static void main(String[] args) {
        int number1 = 5; // Changed from 15
        int number2 = 8; // Changed from 10

        System.out.println("Checking order of " + number1 + " and " + number2 + ":");

        if (number1 < number2) {
            System.out.println("The numbers are in ascending order.");
        } else if (number1 > number2) {
            System.out.println("The numbers are in descending order.");
        } else {
            System.out.println("The numbers are equal.");
        }
    }
}

Guarda el archivo.
Compila el programa nuevamente:
```
javac CheckOrder.java
```

Ejecuta el programa:

java CheckOrder

Ahora la salida debería reflejar el orden ascendente:

Checking order of 5 and 8:
The numbers are in ascending order.

Has modificado con éxito el programa para comprobar si dos números adyacentes están en orden ascendente o descendente. Este es un paso crucial para entender cómo los algoritmos de clasificación determinan la posición correcta de los elementos.

Manejar elementos iguales

En los pasos anteriores, comparamos dos números y comprobamos si estaban en orden ascendente o descendente. También incluimos un caso para cuando los números son iguales. En este paso, nos centraremos específicamente en manejar el escenario en el que los elementos adyacentes son iguales.

Durante la clasificación (sorting), el orden de los elementos iguales generalmente no importa para el resultado final ordenado, pero es importante que nuestra lógica de comparación identifique correctamente este caso. Nuestro programa actual CheckOrder.java ya maneja esto con el bloque else. Vamos a probar explícitamente este caso.

Abre el archivo CheckOrder.java en el editor WebIDE.

Modifica los valores de number1 y number2 para que sean iguales:

public class CheckOrder {
    public static void main(String[] args) {
        int number1 = 7; // Changed to 7
        int number2 = 7; // Changed to 7

        System.out.println("Checking order of " + number1 + " and " + number2 + ":");

        if (number1 < number2) {
            System.out.println("The numbers are in ascending order.");
        } else if (number1 > number2) {
            System.out.println("The numbers are in descending order.");
        } else {
            System.out.println("The numbers are equal.");
        }
    }
}

Guarda el archivo (Ctrl+S o Cmd+S).
En la Terminal, asegúrate de estar en el directorio ~/project:
```
cd ~/project
```
Compila el programa modificado:
```
javac CheckOrder.java
```
La ausencia de salida indica que la compilación fue exitosa.
Ejecuta el programa:
```
java CheckOrder
```
Con ambos números establecidos en 7, la salida ahora debería ser:
```
Checking order of 7 and 7:
The numbers are equal.
```

Esto confirma que nuestro programa identifica correctamente cuando los dos números adyacentes son iguales. Manejar este caso es importante para la completitud de nuestra lógica de comparación.

En el contexto de los algoritmos de clasificación, cuando los elementos adyacentes son iguales, ya están en un orden relativo válido (tanto el orden ascendente como el descendente podrían considerarse verdaderos dependiendo de la estricteza, pero por lo general solo se consideran "iguales" y no es necesario intercambiarlos).

Ahora has probado con éxito el caso en el que los elementos adyacentes son iguales, completando nuestra exploración de la comparación de dos números adyacentes con fines de clasificación.

Resumen

En este laboratorio (lab), comenzamos explorando el concepto fundamental de comparar elementos adyacentes, una idea central en los algoritmos de clasificación (sorting). Aprendimos cómo crear un simple programa en Java para comparar dos números y determinar si uno es mayor, menor o igual al otro. Esto implicó entender la sintaxis básica de Java para la declaración de variables, la asignación y las declaraciones condicionales (if, else if, else). También practicamos la modificación de archivos Java existentes y aprendimos la importancia de que el nombre de la clase coincida con el nombre del archivo.

Basándonos en el concepto de comparar elementos adyacentes, luego extendimos nuestra comprensión para comprobar tanto el orden ascendente como el descendente dentro de una secuencia de números. Esto implicó aplicar la lógica de comparación de forma iterativa a múltiples elementos. Finalmente, abordamos el escenario de manejar elementos iguales durante la comprobación de clasificación, asegurándonos de que nuestra lógica tenga en cuenta correctamente los casos en los que los elementos adyacentes tienen el mismo valor. Estos pasos proporcionaron una comprensión básica de cómo determinar mediante programación si una matriz (array) está ordenada en Java.