Programa Java para ordenar una array en forma de onda

Dada una array no ordenada de enteros, ordene la array en una array similar a una onda. Una array ‘arr[0..n-1]’ se ordena en forma de onda si arr[0] >= arr[1] <= arr[2] >= arr[3] <= arr[4] >= … ..

Ejemplos: 

 Input:  arr[] = {10, 5, 6, 3, 2, 20, 100, 80}
 Output: arr[] = {10, 5, 6, 2, 20, 3, 100, 80} OR
                 {20, 5, 10, 2, 80, 6, 100, 3} OR
                 any other array that is in wave form

 Input:  arr[] = {20, 10, 8, 6, 4, 2}
 Output: arr[] = {20, 8, 10, 4, 6, 2} OR
                 {10, 8, 20, 2, 6, 4} OR
                 any other array that is in wave form

 Input:  arr[] = {2, 4, 6, 8, 10, 20}
 Output: arr[] = {4, 2, 8, 6, 20, 10} OR
                 any other array that is in wave form

 Input:  arr[] = {3, 6, 5, 10, 7, 20}
 Output: arr[] = {6, 3, 10, 5, 20, 7} OR
                 any other array that is in wave form
 

Una solución simple es usar la clasificación. Primero ordene la array de entrada, luego intercambie todos los elementos adyacentes.
Por ejemplo, deje que la array de entrada sea {3, 6, 5, 10, 7, 20}. Después de ordenar, obtenemos {3, 5, 6, 7, 10, 20}. Después de intercambiar elementos adyacentes, obtenemos {5, 3, 7, 6, 20, 10}. 

A continuación se muestran las implementaciones de este enfoque simple. 

// Java implementation of naive method for sorting
// an array in wave form.
import java.util.*;
  
class SortWave
{
    // A utility method to swap two numbers.
    void swap(int arr[], int a, int b)
    {
        int temp = arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }
  
    // This function sorts arr[0..n-1] in wave form, i.e.,
    // arr[0] >= arr[1] <= arr[2] >= arr[3] <= arr[4]..
    void sortInWave(int arr[], int n)
    {
        // Sort the input array
        Arrays.sort(arr);
  
        // Swap adjacent elements
        for (int i=0; i<n-1; i += 2)
            swap(arr, i, i+1);
    }
  
    // Driver method
    public static void main(String args[])
    {
        SortWave ob = new SortWave();
        int arr[] = {10, 90, 49, 2, 1, 5, 23};
        int n = arr.length;
        ob.sortInWave(arr, n);
        for (int i : arr)
            System.out.print(i + " ");
    }
}
/*This code is contributed by Rajat Mishra*/

Producción: 

2 1 10 5 49 23 90

La complejidad temporal de la solución anterior es O(nLogn) si se utiliza un algoritmo de clasificación O(nLogn) como Merge Sort , Heap Sort , etc.
Esto se puede hacer en tiempo O (n) haciendo un solo recorrido de la array dada. La idea se basa en el hecho de que si nos aseguramos de que todos los elementos con posiciones pares (en el índice 0, 2, 4, ..) sean mayores que sus elementos impares adyacentes, no tenemos que preocuparnos por los elementos con posiciones impares. Los siguientes son pasos simples. 
1) Atraviese todos los elementos posicionados pares de la array de entrada y haga lo siguiente. 
….a) Si el elemento actual es más pequeño que el elemento impar anterior, intercambie anterior y actual. 
….b) Si el elemento actual es más pequeño que el siguiente elemento impar, cambie el siguiente y el actual.

A continuación se muestran implementaciones del algoritmo simple anterior. 

// A O(n) Java program to sort an input array in wave form
class SortWave
{
    // A utility method to swap two numbers.
    void swap(int arr[], int a, int b)
    {
        int temp = arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }
  
    // This function sorts arr[0..n-1] in wave form, i.e.,
    // arr[0] >= arr[1] <= arr[2] >= arr[3] <= arr[4]....
    void sortInWave(int arr[], int n)
    {
        // Traverse all even elements
        for (int i = 0; i < n; i+=2)
        {
            // If current even element is smaller
            // than previous
            if (i>0 && arr[i-1] > arr[i] )
                swap(arr, i-1, i);
  
            // If current even element is smaller
            // than next
            if (i<n-1 && arr[i] < arr[i+1] )
                swap(arr, i, i + 1);
        }
    }
  
    // Driver program to test above function
    public static void main(String args[])
    {
        SortWave ob = new SortWave();
        int arr[] = {10, 90, 49, 2, 1, 5, 23};
        int n = arr.length;
        ob.sortInWave(arr, n);
        for (int i : arr)
            System.out.print(i+" ");
    }
}
/*This code is contributed by Rajat Mishra*/

Producción: 

90 10 49 1 5 2 23
 

Consulte el artículo completo sobre Ordenar una array en forma de onda para obtener más detalles.