Programa Javascript 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. 

<script>
  
// A JavaScript program to sort an array 
// in wave form using a sorting function
  
// A utility method to swap two numbers.
function swap(arr, x, y)
{
    let temp = arr[x];
    arr[x] = arr[y];
    arr[y] = temp
}
  
// This function sorts arr[0..n-1] in 
// wave form, i.e.,
// arr[0] >= arr[1] <= arr[2] >= 
// arr[3] <= arr[4] >= arr[5]..
function sortInWave(arr, n)
{
      
    // Sort the input array
    arr.sort((a, b) => a - b);
  
    // Swap adjacent elements
    for(let i = 0; i < n - 1; i += 2)
        swap(arr, i, i + 1);
}
  
// Driver code
let arr = [ 10, 90, 49, 2, 1, 5, 23 ];
let n = arr.length;
  
sortInWave(arr, n);
  
for(let i = 0; i < n; i++)
    document.write(arr[i] + " ");
  
// This code is contributed by Surbhi Tyagi.
  
</script>

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. 

<script>
  
// A O(n) program to sort 
// an input array in wave form
  
// A utility method to swap two numbers.
function swap(arr, a, b)
    {
        let 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]....
function sortInWave( arr, n)
    {
        // Traverse all even elements
        for (let 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 code 
      
    let arr = [10, 90, 49, 2, 1, 5, 23];
    let n = arr.length;
    sortInWave(arr, n);
    for (let i=0; i<n; i++)
      document.write(arr[i] + " ");
      
</script>

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.