Reorganizar una array en forma mínima máxima | Serie 1

Dada una array ordenada de enteros positivos, reorganice la array alternativamente, es decir, el primer elemento debe ser el valor máximo, el segundo valor mínimo, el tercer segundo máximo, el cuarto segundo mínimo y así sucesivamente. 

Ejemplos: 

// C++ program to rearrange an array in minimum
// maximum form
#include <bits/stdc++.h>
using namespace std;
 
// Prints max at first position, min at second position
// second max at third position, second min at fourth
// position and so on.
void rearrange(int arr[], int n)
{
    // Auxiliary array to hold modified array
    int temp[n];
 
    // Indexes of smallest and largest elements
    // from remaining array.
    int small = 0, large = n - 1;
 
    // To indicate whether we need to copy remaining
    // largest or remaining smallest at next position
    int flag = true;
 
    // Store result in temp[]
    for (int i = 0; i < n; i++) {
        if (flag)
            temp[i] = arr[large--];
        else
            temp[i] = arr[small++];
 
        flag = !flag;
    }
 
    // Copy temp[] to arr[]
    for (int i = 0; i < n; i++)
        arr[i] = temp[i];
}
 
// Driver code
int main()
{
    int arr[] = { 1, 2, 3, 4, 5, 6 };
    int n = sizeof(arr) / sizeof(arr[0]);
 
    cout << "Original Array\n";
    for (int i = 0; i < n; i++)
        cout << arr[i] << " ";
 
    rearrange(arr, n);
 
    cout << "\nModified Array\n";
    for (int i = 0; i < n; i++)
        cout << arr[i] << " ";
    return 0;
}

// Java program to rearrange an array in minimum
// maximum form
 
import java.util.Arrays;
 
public class GFG
{
    // Prints max at first position, min at second position
    // second max at third position, second min at fourth
    // position and so on.
    static void rearrange(int[] arr, int n)
    {
        // Auxiliary array to hold modified array
        int temp[] = arr.clone();
 
        // Indexes of smallest and largest elements
        // from remaining array.
        int small = 0, large = n - 1;
 
        // To indicate whether we need to copy remaining
        // largest or remaining smallest at next position
        boolean flag = true;
 
        // Store result in temp[]
        for (int i = 0; i < n; i++) {
            if (flag)
                arr[i] = temp[large--];
            else
                arr[i] = temp[small++];
 
            flag = !flag;
        }
    }
 
    // Driver code
    public static void main(String[] args)
    {
        int arr[] = new int[] { 1, 2, 3, 4, 5, 6 };
 
        System.out.println("Original Array ");
        System.out.println(Arrays.toString(arr));
 
        rearrange(arr, arr.length);
 
        System.out.println("Modified Array ");
        System.out.println(Arrays.toString(arr));
    }
}

# Python program to rearrange an array in minimum
# maximum form
 
# Prints max at first position, min at second position
# second max at third position, second min at fourth
# position and so on.
 
 
def rearrange(arr, n):
    # Auxiliary array to hold modified array
    temp = n*[None]
 
    # Indexes of smallest and largest elements
    # from remaining array.
    small, large = 0, n-1
 
    # To indicate whether we need to copy remaining
    # largest or remaining smallest at next position
    flag = True
 
    # Store result in temp[]
    for i in range(n):
        if flag is True:
            temp[i] = arr[large]
            large -= 1
        else:
            temp[i] = arr[small]
            small += 1
 
        flag = bool(1-flag)
 
    # Copy temp[] to arr[]
    for i in range(n):
        arr[i] = temp[i]
    return arr
 
 
# Driver code
arr = [1, 2, 3, 4, 5, 6]
n = len(arr)
print("Original Array")
print(arr)
print("Modified Array")
print(rearrange(arr, n))
 
# This code is contributed by Pratik Chhajer

// C# program to rearrange
// an array in minimum
// maximum form
using System;
 
class GFG {
 
    // Prints max at first position,
    // min at second position second
    // max at third position, second
    // min at fourth position and so on.
    static void rearrange(int[] arr, int n)
    {
        // Auxiliary array to
        // hold modified array
        int[] temp = new int[n];
 
        // Indexes of smallest
        // and largest elements
        // from remaining array.
        int small = 0, large = n - 1;
 
        // To indicate whether we
        // need to copy remaining
        // largest or remaining
        // smallest at next position
        bool flag = true;
 
        // Store result in temp[]
        for (int i = 0; i < n; i++) {
            if (flag)
                temp[i] = arr[large--];
            else
                temp[i] = arr[small++];
 
            flag = !flag;
        }
 
        // Copy temp[] to arr[]
        for (int i = 0; i < n; i++)
            arr[i] = temp[i];
    }
 
    // Driver Code
    static void Main()
    {
        int[] arr = { 1, 2, 3, 4, 5, 6 };
 
        Console.WriteLine("Original Array");
        for (int i = 0; i < arr.Length; i++)
            Console.Write(arr[i] + " ");
 
        rearrange(arr, arr.Length);
 
        Console.WriteLine("\nModified Array");
        for (int i = 0; i < arr.Length; i++)
            Console.Write(arr[i] + " ");
    }
}
 
// This code is contributed
// by Sam007

<?php
// PHP program to rearrange an array in
// minimum-maximum form
 
// Prints max at first position, min at
// second position second max at third
// position, second min at fourth
// position and so on.
function rearrange(&$arr, $n)
{
    // Auxiliary array to hold modified array
    $temp = array();
 
    // Indexes of smallest and largest elements
    // from remaining array.
    $small = 0;
    $large = $n - 1;
 
    // To indicate whether we need to copy
    // remaining largest or remaining smallest
    // at next position
    $flag = true;
 
    // Store result in temp[]
    for ($i = 0; $i < $n; $i++)
    {
        if ($flag)
            $temp[$i] = $arr[$large--];
        else
            $temp[$i] = $arr[$small++];
 
        $flag = !$flag;
    }
 
    // Copy temp[] to arr[]
    for ($i = 0; $i < $n; $i++)
        $arr[$i] = $temp[$i];
}
 
// Driver Code
$arr = array(1, 2, 3, 4, 5, 6);
$n = count($arr);
 
echo "Original Arrayn\n";
for ($i = 0; $i < $n; $i++)
    echo $arr[$i] . " ";
 
rearrange($arr, $n);
 
echo "\nModified Arrayn\n";
for ($i = 0; $i < $n; $i++)
    echo $arr[$i] . " ";
     
// This code is contributed by
// Rajput-Ji
?>

<script>
 
// JavaScript program to rearrange an array in minimum
// maximum form
 
// Prints max at first position, min at second position
// second max at third position, second min at fourth
// position and so on.
function rearrange(arr, n)
{
    // Auxiliary array to hold modified array
    let temp = new Array(n);
 
    // Indexes of smallest and largest elements
    // from remaining array.
    let small = 0, large = n - 1;
 
    // To indicate whether we need to copy remaining
    // largest or remaining smallest at next position
    let flag = true;
 
    // Store result in temp[]
    for (let i = 0; i < n; i++) {
        if (flag)
            temp[i] = arr[large--];
        else
            temp[i] = arr[small++];
 
        flag = !flag;
    }
 
    // Copy temp[] to arr[]
    for (let i = 0; i < n; i++)
        arr[i] = temp[i];
}
 
// Driver code
    let arr = [ 1, 2, 3, 4, 5, 6 ];
    let n = arr.length;
 
    document.write("Original Array<br>");
    for (let i = 0; i < n; i++)
        document.write(arr[i] + " ");
 
    rearrange(arr, n);
 
    document.write("<br>Modified Array<br>");
    for (let i = 0; i < n; i++)
        document.write(arr[i] + " ");
 
// This code is contributed by Surbhi Tyagi.
 
</script>