Programa C++ 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. 

// A C++ program to sort an array in wave form using
// a sorting function
#include<iostream>
#include<algorithm>
using namespace std;
  
// A utility method to swap two numbers.
void swap(int *x, int *y)
{
    int temp = *x;
    *x = *y;
    *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]..
void sortInWave(int arr[], int n)
{
    // Sort the input array
    sort(arr, arr+n);
  
    // Swap adjacent elements
    for (int i=0; i<n-1; i += 2)
        swap(&arr[i], &arr[i+1]);
}
  
// Driver program to test above function
int main()
{
    int arr[] = {10, 90, 49, 2, 1, 5, 23};
    int n = sizeof(arr)/sizeof(arr[0]);
    sortInWave(arr, n);
    for (int i=0; i<n; i++)
       cout << arr[i] << " ";
    return 0;
}

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) program to sort an input array in wave form
#include<iostream>
using namespace std;
  
// A utility method to swap two numbers.
void swap(int *x, int *y)
{
    int temp = *x;
    *x = *y;
    *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] ....
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], &arr[i-1]);
  
        // If current even element is smaller than next
        if (i<n-1 && arr[i] < arr[i+1] )
            swap(&arr[i], &arr[i + 1]);
    }
}
  
// Driver program to test above function
int main()
{
    int arr[] = {10, 90, 49, 2, 1, 5, 23};
    int n = sizeof(arr)/sizeof(arr[0]);
    sortInWave(arr, n);
    for (int i=0; i<n; i++)
       cout << arr[i] << " ";
    return 0;
}

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.