Programa Java para Ordenar los Elementos de un Array en Orden Ascendente

Declaración del problema: ordene la array dada en orden ascendente de modo que los elementos se ordenen de menor a mayor. Considere una ilustración a continuación:

Sea el arreglo original como sigue: 

La array generada después de ordenar la array anterior es la siguiente : 

• Los elementos se ordenan de tal manera que el elemento más pequeño aparecerá en el extremo izquierdo, que en este caso es -9. El elemento más grande aparecerá en el extremo derecho que en este caso es 12.

Enfoques:

1. Uso de clasificación de burbujas (ingenuo)
2. Usando el método sort() de la clase de arrays (óptima)

Enfoque 1: Uso de la clasificación por burbujas

Algoritmo:

1. Compara elementos adyacentes entre sí.
2. Use el bucle for anidado para realizar un seguimiento.
3. Intercambie los elementos si el primer elemento es mayor que el segundo elemento.

Ejemplo

// Java Program to Sort Elements of an Array
// in Ascending Order
 
// Main class
class GFG {
 
    // Declaration global variable length
    static int length;
 
    // Method 1
    // To print the array
    public static void printArray(int[] array)
    {
        // Iterating using for loops
        for (int i = 0; i < length; i++) {
            System.out.print(array[i] + " ");
        }
        System.out.println();
    }
 
    // Method 2
    // To sort an array
    public static void sortArray(int[] array)
    {
        int temporary = 0;
 
        // Sort the array 'arr' elements in ascending order
        // using nested for loops
        for (int i = 0; i < length; i++) {
            for (int j = i + 1; j < length; j++) {
                if (array[i] > array[j]) {
                    temporary = array[i];
                    array[i] = array[j];
                    array[j] = temporary;
                }
            }
        }
 
        // Displaying elements of array after sorting
        System.out.println(
            "Elements of array sorted in ascending order: ");
        printArray(array);
    }
 
    // Method 3
    // Main driver method
    public static void main(String[] args)
    {
        // Initializing custom array elements
        // The array contains 6 elements.
        int[] array = new int[] { -5, -9, 8, 12, 1, 3 };
 
        // Initialize length
        length = array.length;
 
        // Displaying elements of original array
        System.out.print("Elements of original array: ");
 
        // Call printArray method
        printArray(array);
 
        // Call sortArray method
        sortArray(array);
    }
}

Elements of original array: -5 -9 8 12 1 3 
Elements of array sorted in ascending order: 
-9 -5 1 3 8 12 

Complejidad de tiempo: O(n^2), donde n es la longitud de una array.

Enfoque 2: Usar el método sort() de la clase Arrays

El método sort() es un método de clase java.util.Arrays que se utiliza para ordenar elementos de array. Por defecto, ordena los elementos de la array en orden ascendente.

Sintaxis:

Arrays.sort(arrayName);

Parámetros:  Array a ordenar 

Tipo de devolución: NA

Ejemplo

// Java Program to sort the elements of an array
// in Ascending Order by Inbuilt Methods
 
// Importing Arrays class from java.util package
import java.util.Arrays;
 
// Main class
public class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
        // Initialize array
        // The array contains 6 elements.
        int[] array = new int[] { -5, -9, 8, 12, 1, 3 };
 
        // Displaying elements of original array
        System.out.print("Elements of original array: ");
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
 
        // Using Arrays.sort() method to sort array
        // elements in ascending order.
        Arrays.sort(array);
 
        System.out.println();
 
        // Displaying elements of array after sorting
        System.out.println(
            "Elements of array sorted in ascending order : "
            + Arrays.toString(array));
    }
}

Elements of original array: -5 -9 8 12 1 3 
Elements of array sorted in ascending order : [-9, -5, 1, 3, 8, 12]

Complejidad de tiempo: O(n log(n)), donde n es el tamaño de una array.