Array alternativa más pequeña lexicográfica

Dada una array arr[] de elementos distintos, la tarea es reorganizar la array de manera que sea lexicográficamente más pequeña y de la forma arr[0] > arr[1] < arr[2] > arr[3] < …
Ejemplos: 
 

Entrada: arr[] = {3, 2, 1, 4, 5} 
Salida: 2 1 4 3 5
Entrada: arr[] = {10, 22} 
Salida: 22 10 
 

Enfoque: para obtener la array lexicográficamente más pequeña, podemos elegir el elemento mínimo como el primer elemento, pero eso no satisfará la condición en la que el primer elemento debe ser estrictamente mayor que el segundo elemento. 
Ahora, la segunda mejor opción es elegir el segundo mínimo de la array y el único elemento que es más pequeño que el elemento más pequeño que será el segundo elemento de la array. 
Aplique el mismo proceso para el resto de los elementos de la array, elija el segundo mínimo de los elementos restantes y luego elija el mínimo para cada dos posiciones consecutivas que se pueden obtener ordenando primero la array dada y luego intercambiando cada dos elementos consecutivos.
A continuación se muestra la implementación del enfoque anterior: 
 

// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to print the
// contents of an array
void printArr(int arr[], int n)
{
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
}
 
// Function to find the lexicographically
// smallest alternating array
void smallestArr(int arr[], int n)
{
 
    // Sort the array
    sort(arr, arr + n);
 
    // Swap every two consecutive elements
    for (int i = 0; i + 1 < n; i = i + 2) {
        swap(arr[i], arr[i + 1]);
    }
 
    // Print the re-arranged array
    printArr(arr, n);
}
 
// Driver code
int main()
{
    int arr[] = { 3, 2, 1, 4, 5 };
    int n = sizeof(arr) / sizeof(arr[0]);
 
    smallestArr(arr, n);
 
    return 0;
}

// Java implementation of the approach
import java.util.Arrays;
 
class GFG
{
 
    // Function to print the
    // contents of an array
    static void printArr(int[] arr, int n)
    {
        for (int i = 0; i < n; i++)
            System.out.print(arr[i] + " ");
    }
 
    // Function to find the lexicographically
    // smallest alternating array
    static void smallestArr(int[] arr, int n)
    {
 
        // Sort the array
        Arrays.sort(arr);
 
        // Swap every two consecutive elements
        for (int i = 0; i + 1 < n; i = i + 2)
        {
            int temp = arr[i];
            arr[i] = arr[i + 1];
            arr[i + 1] = temp;
        }
 
        // Print the re-arranged array
        printArr(arr, n);
    }
 
    // Driver code
    public static void main(String[] args)
    {
        int[] arr = { 3, 2, 1, 4, 5 };
        int n = arr.length;
        smallestArr(arr, n);
    }
}
 
// This code is contributed by
// sanjeev2552

# Python3 implementation of the approach
 
# Function to print the
# contents of an array
def printArr(arr, n):
    for i in range(n):
        print(arr[i], end = " ");
 
# Function to find the lexicographically
# smallest alternating array
def smallestArr(arr, n):
 
    # Sort the array
    arr.sort();
 
    # Swap every two consecutive elements
    for i in range(0, n - 1, 2):
 
        temp = arr[i];
        arr[i] = arr[i + 1];
        arr[i + 1] = temp;
 
    # Print the re-arranged array
    printArr(arr, n);
 
# Driver code
if __name__ == '__main__':
 
    arr = [ 3, 2, 1, 4, 5 ];
    n = len(arr);
    smallestArr(arr, n);
     
# This code contributed by Rajput-Ji

// C# implementation of the approach
using System;
     
class GFG
{
 
    // Function to print the
    // contents of an array
    static void printArr(int[] arr, int n)
    {
        for (int i = 0; i < n; i++)
            Console.Write(arr[i] + " ");
    }
 
    // Function to find the lexicographically
    // smallest alternating array
    static void smallestArr(int[] arr, int n)
    {
 
        // Sort the array
        Array.Sort(arr);
 
        // Swap every two consecutive elements
        for (int i = 0; i + 1 < n; i = i + 2)
        {
            int temp = arr[i];
            arr[i] = arr[i + 1];
            arr[i + 1] = temp;
        }
 
        // Print the re-arranged array
        printArr(arr, n);
    }
 
    // Driver code
    public static void Main(String[] args)
    {
        int[] arr = { 3, 2, 1, 4, 5 };
        int n = arr.Length;
        smallestArr(arr, n);
    }
}
 
// This code is contributed by 29AjayKumar

<?php
// PHP implementation of the approach
 
// Function to print the
// contents of an array
function printArr($arr, $n)
{
    for ($i = 0; $i < $n; $i++)
    {
        echo $arr[$i];
        echo " ";
    }
}
 
// Function to find the lexicographically
// smallest alternating array
function smallestArr($arr, $n)
{
 
    // Sort the array
    sort($arr);
 
    // Swap every two consecutive elements
    for ($i = 0; $i + 1 < $n; $i = $i + 2)
    {
        $temp = $arr[$i];
        $arr[$i] = $arr[$i + 1];
        $arr[$i + 1] = $temp;
    }
 
    // Print the re-arranged array
    printArr($arr, $n);
}
 
// Driver code
$arr = array( 3, 2, 1, 4, 5 );
$n = count($arr);
 
smallestArr($arr, $n);
 
// This code is contributed by Naman_Garg.
?>

// javascript implementation of the approach
 
    // Function to print the
    // contents of an array
    function printArr(arr, n)
    {
        for (var i = 0; i < n; i++)
            document.write(arr[i] + " ");
    }
   
    // Function to find the lexicographically
    // smallest alternating array
     
    function smallestArr( arr,  n)
    {
   
        // Sort the array       
        arr.sort();
   
        // Swap every two consecutive elements
        for (var i = 0; i + 1 < n; i = i + 2)
        {
            var temp = arr[i];
            arr[i] = arr[i + 1];
            arr[i + 1] = temp;
        }
   
        // Print the re-arranged array
        printArr(arr, n);
    }
   
    // Driver code
        var arr = [ 3, 2, 1, 4, 5 ] ;
        var n = arr.length;
        smallestArr(arr, n);
 
// This code is contributed by bunnyram19.

2 1 4 3 5

Complejidad de tiempo: O (nlogn)

Espacio Auxiliar: O(1)