Programa Java para ordenar los elementos de la array en orden descendente

Ordene la array dada en orden descendente, es decir, ordene los elementos de mayor a menor. 

Ejemplo:

Input :Array = {2, 6, 23, 98, 24, 35, 78}
Output:[98, 78, 35, 24, 23, 6, 2]

Input :Array = {1, 2, 3, 4, 5}
Output:[5, 4, 3, 2, 1]

La clasificación es un proceso de ordenar elementos sistemáticamente. sort() es una función incorporada de java.util.Arrays que se utiliza para ordenar una array de elementos con una complejidad optimizada.

Enfoques

Existen numerosos enfoques para ordenar la array dada en orden descendente en Java. Algunos de ellos se enumeran a continuación.

• Usando el método Collections.reverseOrder()
• Uso de la clasificación y la inversión

1. Usando el método Collections.reverseOrder()

Los elementos de la array se pueden ordenar en orden descendente pasando la array y Collections.reverseOrder() como parámetros a Arrays.sort().

Nota : una cosa a tener en cuenta es que al clasificar en orden descendente, Arrays.sort() no acepta una array del tipo de datos primitivo.

Implementación:

// Java program to sort the elements in descending order
import java.util.*;
  
class GFG {
    public static void main(String[] args)
    {
  
        // Initializing the array
        Integer array[] = { 1, 2, 3, 4, 5 };
  
        // Sorting the array in descending order
        Arrays.sort(array, Collections.reverseOrder());
  
        // Printing the elements
        System.out.println(Arrays.toString(array));
    }
}

[5, 4, 3, 2, 1]

Complejidad de tiempo: O(N log N)

2. Uso de la clasificación y la inversión

• Ordenar la array dada.
• Invierta la array ordenada.

A continuación se muestra la implementación del enfoque anterior:  

// Java program to sort the elements in descending order
import java.util.*;
  
class GFG {
    public static void main(String[] args)
    {
  
        // Initializing the array
        int array[] = { 1, 2, 3, 4, 5, 6 };
  
        // Sorting the array in ascending order
        Arrays.sort(array);
  
        // Reversing the array
        reverse(array);
  
        // Printing the elements
        System.out.println(Arrays.toString(array));
    }
  
    public static void reverse(int[] array)
    {
  
        // Length of the array
        int n = array.length;
  
        // Swaping the first half elements with last half
        // elements
        for (int i = 0; i < n / 2; i++) {
  
            // Storing the first half elements temporarily
            int temp = array[i];
  
            // Assigning the first half to the last half
            array[i] = array[n - i - 1];
  
            // Assigning the last half to the first half
            array[n - i - 1] = temp;
        }
    }
}

[6, 5, 4, 3, 2, 1]

Complejidad de tiempo: O(N log N)