Cómo comprobar si una lista está ordenada en Java

Introducción

En este laboratorio, aprenderás cómo verificar si una lista está ordenada en Java. Exploraremos diferentes enfoques para lograr esta tarea, comenzando con un método fundamental de comparación de elementos adyacentes dentro de la lista.

Luego descubrirás cómo aprovechar el poder de la API de flujos (Stream API) de Java para realizar la comprobación de orden de una manera más concisa y potencialmente más eficiente. Finalmente, abordaremos cómo manejar diferentes órdenes de clasificación, como ascendente y descendente, para hacer tus comprobaciones de orden más versátiles.

Comparar elementos adyacentes de una lista

En este paso, aprenderemos cómo comparar elementos adyacentes en una lista (o más específicamente, una List en Java). Esta es una tarea común cuando necesitas comprobar patrones o el orden dentro de una secuencia de datos. Comenzaremos creando un simple programa en Java que utiliza un bucle para recorrer una lista y comparar cada elemento con el que le sigue inmediatamente.

Primero, creemos un nuevo archivo Java llamado ListComparison.java en tu directorio ~/project. Puedes hacer esto utilizando el Explorador de archivos del WebIDE en el lado izquierdo. Haz clic derecho en el área ~/project, selecciona "Nuevo archivo" y escribe ListComparison.java.

Ahora, abre el archivo ListComparison.java en el editor y agrega el siguiente código:

import java.util.ArrayList;
import java.util.List;

public class ListComparison {

    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        numbers.add(1);
        numbers.add(3);
        numbers.add(2);
        numbers.add(4);
        numbers.add(5);

        System.out.println("Original list: " + numbers);

        // Loop through the list, comparing adjacent elements
        for (int i = 0; i < numbers.size() - 1; i++) {
            Integer currentElement = numbers.get(i);
            Integer nextElement = numbers.get(i + 1);

            System.out.println("Comparing " + currentElement + " and " + nextElement);

            if (currentElement < nextElement) {
                System.out.println(currentElement + " is less than " + nextElement);
            } else if (currentElement > nextElement) {
                System.out.println(currentElement + " is greater than " + nextElement);
            } else {
                System.out.println(currentElement + " is equal to " + nextElement);
            }
        }
    }
}

Desglosemos este código:

• import java.util.ArrayList; y import java.util.List;: Estas líneas importan las clases necesarias para trabajar con listas en Java.
• List<Integer> numbers = new ArrayList<>();: Esto crea una nueva lista llamada numbers que puede contener objetos Integer (números enteros).
• numbers.add(...): Estas líneas agregan elementos a nuestra lista.
• for (int i = 0; i < numbers.size() - 1; i++): Este es un bucle for que recorre la lista. Observa que la condición del bucle es i < numbers.size() - 1. Esto es importante porque estamos comparando numbers.get(i) con numbers.get(i + 1). Si el bucle llegara hasta numbers.size(), i + 1 se saldría de los límites en la última iteración.
• Integer currentElement = numbers.get(i);: Esto obtiene el elemento en el índice actual i.
• Integer nextElement = numbers.get(i + 1);: Esto obtiene el elemento en el siguiente índice i + 1.
• System.out.println(...): Estas líneas imprimen información en la consola, mostrando qué elementos se están comparando y el resultado de la comparación.
• if, else if, else: Estas son declaraciones condicionales que comprueban si el currentElement es menor que, mayor que o igual al nextElement.

Guarda el archivo ListComparison.java (Ctrl+S o Cmd+S).

Ahora, compilemos y ejecutemos el programa. Abre la Terminal en la parte inferior del WebIDE. Asegúrate de estar en el directorio ~/project (puedes usar cd ~/project si es necesario).

Compila el código utilizando javac:

javac ListComparison.java

Si no hay errores, se creará un archivo ListComparison.class. Ahora, ejecuta el código compilado utilizando java:

java ListComparison

Deberías ver una salida similar a esta:

Original list: [1, 3, 2, 4, 5]
Comparing 1 and 3
1 is less than 3
Comparing 3 and 2
3 is greater than 2
Comparing 2 and 4
2 is less than 4
Comparing 4 and 5
4 is less than 5

Esta salida muestra que nuestro programa recorrió exitosamente la lista y comparó cada par de elementos adyacentes, imprimiendo el resultado de cada comparación.

Usar la Stream API para comprobar si está ordenada

En este paso, exploraremos una forma más moderna y a menudo más concisa de comprobar si una lista está ordenada utilizando la API de flujos (Stream API) de Java. La API de flujos, introducida en Java 8, proporciona un enfoque funcional para procesar colecciones de datos.

Modificaremos nuestro programa anterior para incluir un método que compruebe si la lista está ordenada en orden ascendente utilizando flujos.

Abre el archivo ListComparison.java en el editor del WebIDE. Agrega un nuevo método llamado isSortedAscending a la clase ListComparison, fuera del método main pero dentro de las llaves {} de la clase ListComparison.

Aquí está el código actualizado de ListComparison.java:

import java.util.ArrayList;
import java.util.List;
import java.util.stream.IntStream;

public class ListComparison {

    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        numbers.add(1);
        numbers.add(3);
        numbers.add(2);
        numbers.add(4);
        numbers.add(5);

        System.out.println("Original list: " + numbers);

        // Check if the list is sorted using the new method
        boolean sorted = isSortedAscending(numbers);

        if (sorted) {
            System.out.println("The list is sorted in ascending order.");
        } else {
            System.out.println("The list is NOT sorted in ascending order.");
        }

        // The previous loop for comparison is removed for simplicity in this step
        // but you can keep it if you want to see both methods in action.
    }

    // Method to check if the list is sorted in ascending order using Streams
    public static boolean isSortedAscending(List<Integer> list) {
        if (list == null || list.size() <= 1) {
            return true; // An empty or single-element list is considered sorted
        }

        return IntStream.range(0, list.size() - 1)
                .allMatch(i -> list.get(i).compareTo(list.get(i + 1)) <= 0);
    }
}

Veamos las nuevas partes:

• import java.util.stream.IntStream;: Esto importa la clase IntStream, que es útil para trabajar con secuencias de enteros en flujos.
• public static boolean isSortedAscending(List<Integer> list): Esto declara un nuevo método estático llamado isSortedAscending que toma una List de Integer y devuelve un boolean (true si está ordenada, false en caso contrario).
• if (list == null || list.size() <= 1): Esto maneja casos extremos: una lista vacía o una lista con un solo elemento siempre se considera ordenada.
• IntStream.range(0, list.size() - 1): Esto crea un flujo de enteros desde 0 hasta (pero sin incluir) list.size() - 1. Estos enteros representan los índices de los elementos de la lista que queremos comparar.
• .allMatch(i -> list.get(i).compareTo(list.get(i + 1)) <= 0): Este es el núcleo de la operación de flujo.
  • allMatch() es una operación terminal que comprueba si todos los elementos del flujo cumplen una determinada condición.
  • i -> list.get(i).compareTo(list.get(i + 1)) <= 0 es una expresión lambda que define la condición. Para cada índice i del IntStream, obtiene el elemento en el índice i y el elemento en el índice i + 1.
  • list.get(i).compareTo(list.get(i + 1)) compara los dos elementos. compareTo devuelve un entero negativo si el primer elemento es menor que el segundo, cero si son iguales y un entero positivo si el primer elemento es mayor que el segundo.
  • <= 0 comprueba si el resultado de compareTo es menor o igual a cero. Esta condición es verdadera si el elemento actual es menor o igual al siguiente elemento, que es la definición de orden ascendente.
  • allMatch devuelve true solo si esta condición es verdadera para todos los pares adyacentes de la lista.

Guarda el archivo ListComparison.java.

Ahora, compila y ejecuta el programa actualizado en la Terminal:

javac ListComparison.java

java ListComparison

La salida ahora debe indicar si la lista está ordenada en orden ascendente según el método isSortedAscending:

Original list: [1, 3, 2, 4, 5]
The list is NOT sorted in ascending order.

Modifica la lista en el método main para que esté ordenada, por ejemplo:

        List<Integer> numbers = new ArrayList<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
        numbers.add(4);
        numbers.add(5);

Guarda el archivo, compila y ejecuta de nuevo. La salida ahora debe ser:

Original list: [1, 2, 3, 4, 5]
The list is sorted in ascending order.

Esto demuestra cómo utilizar la API de flujos para realizar una comprobación concisa de orden ascendente.

Manejar diferentes órdenes de clasificación

En el paso anterior, creamos un método para comprobar si una lista está ordenada en orden ascendente. En este paso, ampliaremos nuestro programa para manejar diferentes órdenes de clasificación: ascendente y descendente. Agregaremos un nuevo método que tome la lista y el orden de clasificación deseado como entrada.

Abre el archivo ListComparison.java en el editor del WebIDE. Agregaremos un nuevo método llamado isSorted que tome la lista y un valor boolean que indique si queremos comprobar el orden ascendente (true) o descendente (false).

Aquí está el código actualizado de ListComparison.java:

import java.util.ArrayList;
import java.util.List;
import java.util.stream.IntStream;

public class ListComparison {

    public static void main(String[] args) {
        List<Integer> numbersAsc = new ArrayList<>();
        numbersAsc.add(1);
        numbersAsc.add(2);
        numbersAsc.add(3);
        numbersAsc.add(4);
        numbersAsc.add(5);

        List<Integer> numbersDesc = new ArrayList<>();
        numbersDesc.add(5);
        numbersDesc.add(4);
        numbersDesc.add(3);
        numbersDesc.add(2);
        numbersDesc.add(1);

        List<Integer> numbersUnsorted = new ArrayList<>();
        numbersUnsorted.add(1);
        numbersUnsorted.add(3);
        numbersUnsorted.add(2);
        numbersUnsorted.add(4);
        numbersUnsorted.add(5);


        System.out.println("Checking list: " + numbersAsc);
        System.out.println("Is ascending sorted? " + isSorted(numbersAsc, true));
        System.out.println("Is descending sorted? " + isSorted(numbersAsc, false));
        System.out.println();

        System.out.println("Checking list: " + numbersDesc);
        System.out.println("Is ascending sorted? " + isSorted(numbersDesc, true));
        System.out.println("Is descending sorted? " + isSorted(numbersDesc, false));
        System.out.println();

        System.out.println("Checking list: " + numbersUnsorted);
        System.out.println("Is ascending sorted? " + isSorted(numbersUnsorted, true));
        System.out.println("Is descending sorted? " + isSorted(numbersUnsorted, false));
        System.out.println();

    }

    // Method to check if the list is sorted based on the specified order
    public static boolean isSorted(List<Integer> list, boolean ascending) {
        if (list == null || list.size() <= 1) {
            return true; // An empty or single-element list is considered sorted
        }

        return IntStream.range(0, list.size() - 1)
                .allMatch(i -> {
                    int comparison = list.get(i).compareTo(list.get(i + 1));
                    if (ascending) {
                        return comparison <= 0; // For ascending, current must be <= next
                    } else {
                        return comparison >= 0; // For descending, current must be >= next
                    }
                });
    }
}

Veamos los cambios:

• Hemos creado tres listas diferentes en main: numbersAsc (ordenada ascendentemente), numbersDesc (ordenada descendentemente) y numbersUnsorted.
• Llamamos al nuevo método isSorted con cada lista y con true (para ascendente) y false (para descendente) como valor del parámetro ascending.
• public static boolean isSorted(List<Integer> list, boolean ascending): Esta es la nueva firma de nuestro método, que acepta la lista y una bandera booleana para el orden.
• Dentro de la expresión lambda allMatch:
  • int comparison = list.get(i).compareTo(list.get(i + 1));: Realizamos la comparación entre elementos adyacentes.
  • if (ascending): Si la bandera ascending es verdadera, comprobamos si comparison <= 0 (el elemento actual es menor o igual al siguiente).
  • else: Si la bandera ascending es falsa (lo que significa que estamos comprobando el orden descendente), comprobamos si comparison >= 0 (el elemento actual es mayor o igual al siguiente).

Guarda el archivo ListComparison.java.

Ahora, compila y ejecuta el programa actualizado en la Terminal:

javac ListComparison.java

java ListComparison

La salida debe mostrar los resultados de comprobar cada lista tanto en orden ascendente como en orden descendente:

Checking list: [1, 2, 3, 4, 5]
Is ascending sorted? true
Is descending sorted? false

Checking list: [5, 4, 3, 2, 1]
Is ascending sorted? false
Is descending sorted? true

Checking list: [1, 3, 2, 4, 5]
Is ascending sorted? false
Is descending sorted? false

Esto demuestra cómo crear un método flexible utilizando la API de flujos (Stream API) para comprobar diferentes órdenes de clasificación ajustando la lógica de comparación en función de un parámetro de entrada.

Resumen

En este laboratorio (lab), aprendimos cómo comprobar si una lista está ordenada en Java utilizando diferentes enfoques. Comenzamos implementando un método para comparar elementos adyacentes en una lista utilizando un bucle tradicional, lo cual proporciona una comprensión fundamental de la lógica de comprobación de ordenación. Esto implicó recorrer la lista y comparar cada elemento con su sucesor para identificar cualquier par desordenado.

Posteriormente, exploramos cómo aprovechar la API de flujos (Stream API) de Java para un enfoque más conciso y funcional de comprobar si una lista está ordenada. Este método utiliza operaciones de flujo para determinar de manera eficiente si los elementos están en el orden deseado. Finalmente, abordamos el manejo de diferentes órdenes de clasificación (ascendente y descendente) al realizar la comprobación de ordenación, demostrando cómo adaptar la lógica de comparación para satisfacer diversos requisitos de clasificación.