Sort even-placed elements in increasing and odd-placed in decreasing order

We are given an array of n distinct numbers. The task is to sort all even-placed numbers in increasing and odd-placed numbers in decreasing order. The modified array should contain all sorted even-placed numbers followed by reverse sorted odd-placed numbers.

Note that the first element is considered as even placed because of its index 0. 

Examples:

Input:  arr[] = {0, 1, 2, 3, 4, 5, 6, 7}
Output: arr[] = {0, 2, 4, 6, 7, 5, 3, 1}
Even-place elements : 0, 2, 4, 6
Odd-place elements : 1, 3, 5, 7
Even-place elements in increasing order : 
0, 2, 4, 6
Odd-Place elements in decreasing order : 
7, 5, 3, 1

Input: arr[] = {3, 1, 2, 4, 5, 9, 13, 14, 12}
Output: {2, 3, 5, 12, 13, 14, 9, 4, 1}
Even-place elements : 3, 2, 5, 13, 12
Odd-place elements : 1, 4, 9, 14
Even-place elements in increasing order : 
2, 3, 5, 12, 13
Odd-Place elements in decreasing order : 
14, 9, 4, 1 

The idea is simple. We create two auxiliary arrays evenArr[] and oddArr[] respectively. We traverse input array and put all even-placed elements in evenArr[] and odd placed elements in oddArr[]. Then we sort evenArr[] in ascending and oddArr[] in descending order. Finally, copy evenArr[] and oddArr[] to get the required result.

Implementation:

C++

// Program to separately sort even-placed and odd
// placed numbers and place them together in sorted
// array.
#include <bits/stdc++.h>
using namespace std;

void bitonicGenerator(int arr[], int n)
{
    // create evenArr[] and oddArr[]
    vector<int> evenArr;
    vector<int> oddArr;

    // Put elements in oddArr[] and evenArr[] as
    // per their position
    for (int i = 0; i < n; i++) {
        if (!(i % 2))
            evenArr.push_back(arr[i]);
        else
            oddArr.push_back(arr[i]);
    }

    // sort evenArr[] in ascending order
    // sort oddArr[] in descending order
    sort(evenArr.begin(), evenArr.end());
    sort(oddArr.begin(), oddArr.end(), greater<int>());

    int i = 0;
    for (int j = 0; j < evenArr.size(); j++)
        arr[i++] = evenArr[j];
    for (int j = 0; j < oddArr.size(); j++)
        arr[i++] = oddArr[j];
}

// Driver Program
int main()
{
    int arr[] = { 1, 5, 8, 9, 6, 7, 3, 4, 2, 0 };
    int n = sizeof(arr) / sizeof(arr[0]);
    bitonicGenerator(arr, n);
    for (int i = 0; i < n; i++)
        cout << arr[i] << " ";
    return 0;
}

Java

// Java Program to separately sort
// even-placed and odd placed numbers
// and place them together in sorted
// array.
import java.util.*;

class GFG {

    static void bitonicGenerator(int arr[], int n)
    {
        // create evenArr[] and oddArr[]
        Vector<Integer> evenArr = new Vector<Integer>();
        Vector<Integer> oddArr = new Vector<Integer>();

        // Put elements in oddArr[] and evenArr[] as
        // per their position
        for (int i = 0; i < n; i++) {
            if (i % 2 != 1) {
                evenArr.add(arr[i]);
            }
            else {
                oddArr.add(arr[i]);
            }
        }

        // sort evenArr[] in ascending order
        // sort oddArr[] in descending order
        Collections.sort(evenArr);
        Collections.sort(oddArr, Collections.reverseOrder());

        int i = 0;
        for (int j = 0; j < evenArr.size(); j++) {
            arr[i++] = evenArr.get(j);
        }
        for (int j = 0; j < oddArr.size(); j++) {
            arr[i++] = oddArr.get(j);
        }
    }

    // Driver code
    public static void main(String[] args)
    {
        int arr[] = { 1, 5, 8, 9, 6, 7, 3, 4, 2, 0 };
        int n = arr.length;
        bitonicGenerator(arr, n);
        for (int i = 0; i < n; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

/* This code contributed by PrinciRaj1992 */

Python3

# Python3 program to separately sort
# even-placed and odd placed numbers
# and place them together in sorted array.
def bitonicGenerator(arr, n):

    # create evenArr[] and oddArr[]
    evenArr = []
    oddArr = []

    # Put elements in oddArr[] and evenArr[]
    # as per their position
    for i in range(n):
        if ((i % 2) == 0):
            evenArr.append(arr[i])
        else:
            oddArr.append(arr[i])

    # sort evenArr[] in ascending order
    # sort oddArr[] in descending order
    evenArr = sorted(evenArr)
    oddArr = sorted(oddArr)
    oddArr = oddArr[::-1]

    i = 0
    for j in range(len(evenArr)):
        arr[i] = evenArr[j]
        i += 1
    for j in range(len(oddArr)):
        arr[i] = oddArr[j]
        i += 1

# Driver Code
arr = [1, 5, 8, 9, 6, 7, 3, 4, 2, 0]
n = len(arr)
bitonicGenerator(arr, n)
for i in arr:
    print(i, end = " ")

# This code is contributed by Mohit Kumar

C#

// C# Program to separately sort
// even-placed and odd placed numbers
// and place them together in sorted
// array.
using System;
using System.Collections.Generic;

class GFG
{

    static void bitonicGenerator(int []arr, int n)
    {
        // create evenArr[] and oddArr[]
        List<int> evenArr = new List<int>();
        List<int> oddArr = new List<int>();
        int i = 0;

        // Put elements in oddArr[] and evenArr[] as
        // per their position
        for (i = 0; i < n; i++)
        {
            if (i % 2 != 1)
            {
                evenArr.Add(arr[i]);
            }
            else
            {
                oddArr.Add(arr[i]);
            }
        }

        // sort evenArr[] in ascending order
        // sort oddArr[] in descending order
        evenArr.Sort();
        oddArr.Sort();
        oddArr.Reverse();

        i = 0;
        for (int j = 0; j < evenArr.Count; j++)
        {
            arr[i++] = evenArr[j];
        }
        for (int j = 0; j < oddArr.Count; j++)
        {
            arr[i++] = oddArr[j];
        }
    }

    // Driver code
    public static void Main(String[] args)
    {
        int []arr = { 1, 5, 8, 9, 6, 7, 3, 4, 2, 0 };
        int n = arr.Length;
        bitonicGenerator(arr, n);
        for (int i = 0; i < n; i++)
        {
            Console.Write(arr[i] + " ");
        }
    }
}

// This code contributed by Rajput-Ji

Javascript

<script>
// Javascript Program to separately sort
// even-placed and odd placed numbers
// and place them together in sorted
// array.

    function bitonicGenerator(arr,n)
    {
        // create evenArr[] and oddArr[]
        let evenArr = [];
        let oddArr = [];

        // Put elements in oddArr[] and evenArr[] as
        // per their position
        for (let i = 0; i < n; i++) {
            if (i % 2 != 1) {
                evenArr.push(arr[i]);
            }
            else {
                oddArr.push(arr[i]);
            }
        }

        // sort evenArr[] in ascending order
        // sort oddArr[] in descending order
        evenArr.sort(function(a,b){return a-b;});
        oddArr.sort(function(a,b){return b-a;});

        let i = 0;
        for (let j = 0; j < evenArr.length; j++) {
            arr[i++] = evenArr[j];
        }
        for (let j = 0; j < oddArr.length; j++) {
            arr[i++] = oddArr[j];
        }
    }

     // Driver code
    let arr=[1, 5, 8, 9, 6, 7, 3, 4, 2, 0 ];
    let  n = arr.length;
    bitonicGenerator(arr, n);
    for (let i = 0; i < n; i++) {
        document.write(arr[i] + " ");
    }

    // This code is contributed by unknown2108
</script>

Output

1 2 3 6 8 9 7 5 4 0 

Time Complexity: O(n Log n) 
Auxiliary Space: O(n)

The above problem can also be solved without the use of Auxiliary space. The idea is to swap the first half odd index positions with the second half even index positions and then sort the first half array in increasing order and the second half array in decreasing order. Thanks to SWARUPANANDA DHUA for suggesting this.

Implementation:

C++

// Program to sort even-placed elements in increasing and
// odd-placed in decreasing order with constant space complexity

#include <bits/stdc++.h>
using namespace std;

void bitonicGenerator(int arr[], int n)
{
    // first odd index
    int i = 1;

    // last index
    int j = n - 1;

    // if last index is odd
    if (j % 2 != 0)
        // decrement j to even index
        j--;

    // swapping till half of array
    while (i < j) {
        swap(arr[i], arr[j]);
        i += 2;
        j -= 2;
    }

    // Sort first half in increasing
    sort(arr, arr + (n + 1) / 2);

    // Sort second half in decreasing
    sort(arr + (n + 1) / 2, arr + n, greater<int>());
}

// Driver Program
int main()
{
    int arr[] = { 1, 5, 8, 9, 6, 7, 3, 4, 2, 0 };
    int n = sizeof(arr) / sizeof(arr[0]);
    bitonicGenerator(arr, n);
    for (int i = 0; i < n; i++)
        cout << arr[i] << " ";
    return 0;
}
// This code is contributed by SWARUPANANDA DHUA

Java

// Program to sort even-placed elements in increasing and
// odd-placed in decreasing order with constant space complexity
import java.util.Arrays;
class GFG {

    static void bitonicGenerator(int arr[], int n)
    {
        // first odd index
        int i = 1;

        // last index
        int j = n - 1;

        // if last index is odd
        if (j % 2 != 0)
            // decrement j to even index
            j--;

        // swapping till half of array
        while (i < j) {
            arr = swap(arr, i, j);
            i += 2;
            j -= 2;
        }

        // Sort first half in increasing
        Arrays.sort(arr, 0, (n + 1) / 2);

        // Sort second half in decreasing
        Arrays.sort(arr, (n + 1) / 2, n);
        int low = (n + 1) / 2, high = n - 1;
        // Reverse the second half
        while (low < high) {
            Integer temp = arr[low];
            arr[low] = arr[high];
            arr[high] = temp;
            low++;
            high--;
        }
    }
    static int[] swap(int[] arr, int i, int j)
    {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
        return arr;
    }
    // Driver Program
    public static void main(String[] args)
    {
        int arr[] = { 1, 5, 8, 9, 6, 7, 3, 4, 2, 0 };
        int n = arr.length;
        bitonicGenerator(arr, n);
        for (int i = 0; i < n; i++)
            System.out.print(arr[i] + " ");
    }
}
// This code has been contributed by 29AjayKumar

Python3

# Python3 Program to sort even-placed elements in increasing and
# odd-placed in decreasing order with constant space complexity
def bitonicGenerator(arr, n):

    # first odd index
    i = 1

    # last index
    j = n - 1

    # if last index is odd
    if (j % 2 != 0):

        # decrement j to even index
        j = j - 1

    # swapping till half of array
    while (i < j) :
        arr[j], arr[i] = arr[i], arr[j]
        i = i + 2
        j = j - 2

    arr_f = []
    arr_s = []

    for i in range(int((n + 1) / 2)) :
        arr_f.append(arr[i])

    i = int((n + 1) / 2)
    while( i < n ) :
        arr_s.append(arr[i])
        i = i + 1

    # Sort first half in increasing
    arr_f.sort()

    # Sort second half in decreasing
    arr_s.sort(reverse = True)

    for i in arr_s:
        arr_f.append(i)

    return arr_f

# Driver Program
arr = [ 1, 5, 8, 9, 6, 7, 3, 4, 2, 0]
n = len(arr)
arr = bitonicGenerator(arr, n)
print(arr)

# This code is contributed by Arnab Kundu

C#

// Program to sort even-placed elements in
// increasing and odd-placed in decreasing order
// with constant space complexity
using System;

class GFG
{
    static void bitonicGenerator(int []arr, int n)
    {
        // first odd index
        int i = 1;

        // last index
        int j = n - 1;

        // if last index is odd
        if (j % 2 != 0)

            // decrement j to even index
            j--;

        // swapping till half of array
        while (i < j)
        {
            arr = swap(arr, i, j);
            i += 2;
            j -= 2;
        }

        // Sort first half in increasing
        Array.Sort(arr, 0, (n + 1) / 2);

        // Sort second half in decreasing
        Array.Sort(arr, (n + 1) / 2,
                   n - ((n + 1) / 2));
        int low = (n + 1) / 2, high = n - 1;

        // Reverse the second half
        while (low < high)
        {
            int temp = arr[low];
            arr[low] = arr[high];
            arr[high] = temp;
            low++;
            high--;
        }
    }

    static int[] swap(int[] arr, int i, int j)
    {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
        return arr;
    }

    // Driver Code
    public static void Main(String[] args)
    {
        int []arr = { 1, 5, 8, 9, 6, 7, 3, 4, 2, 0 };
        int n = arr.Length;
        bitonicGenerator(arr, n);
        for (int i = 0; i < n; i++)
            Console.Write(arr[i] + " ");
    }
}

// This code is contributed by PrinciRaj1992

Javascript

<script>
// Program to sort even-placed elements in increasing and
// odd-placed in decreasing order with constant space complexity
function bitonicGenerator(arr, n)
{

    // first odd index
        let i = 1;

        // last index
        let j = n - 1;

        // if last index is odd
        if (j % 2 != 0)
            // decrement j to even index
            j--;

        // swapping till half of array
        while (i < j) {
            arr = swap(arr, i, j);
            i += 2;
            j -= 2;
        }

        // Sort first half in increasing
        // Sort second half in decreasing
        let temp1 = arr.slice(0,Math.floor((n+1)/2)).sort(function(a,b){return a-b;});
        let temp2 = arr.slice(Math.floor((n+1)/2),n).sort(function(a,b){return b-a;});
        arr = temp1.concat(temp2);

        return arr;
}

function swap(arr, i, j)
{
    let temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
        return arr;
}

// Driver Program
let arr = [1, 5, 8, 9, 6, 7, 3, 4, 2, 0 ];
let n = arr.length;
arr = bitonicGenerator(arr, n);
document.write(arr.join(" "));

// This code is contributed by rag2127
</script>

Output

1 2 3 6 8 9 7 5 4 0 

Time Complexity: O(n Log n) 
Auxiliary Space: O(1)

Another approach:
Another efficient approach to solve the problem in O(1) Auxiliary space is by Using negative multiplication.

The steps involved are as follows:

1.  Multiply all the elements at even placed index by -1.
2. Sort the whole array. In this way, we can get all even placed index in the starting as they are negative numbers now.
3. Now revert the sign of these elements.
4. After this reverse the first half of the array which contains an even placed number to make it in increasing order.
5. And then reverse the rest half of the array to make odd placed numbers in decreasing order.

Note: This method is only applicable if all the elements in the array are non-negative.

An illustrative example of the above approach:

Let given array: arr[] = {0, 1, 2, 3, 4, 5, 6, 7}
Array after multiplying by -1 to even placed elements: arr[] = {0, 1, -2, 3, -4, 5, -6, 7}
Array after sorting: arr[] = {-6, -4, -2, 0, 1, 3, 5, 7}
Array after reverting negative values: arr[] = {6, 4, 2, 0, 1, 3, 5, 7}
After reversing the first half of array: arr[] = {0, 2, 4, 6, 1, 3, 5, 7}
After reversing the second half of array: arr[] = {0, 2, 4, 6, 7, 5, 3, 1}

Below is the code for the above approach:

C++

// C++ Program to sort even-placed elements in increasing and
// odd-placed in decreasing order with constant space complexity
#include <bits/stdc++.h>
using namespace std;

void bitonicGenerator(int arr[], int n)
{
    // Making all even placed index
    // element negative
    for (int i = 0; i < n; i++) {
        if (i % 2==0)
            arr[i]=-1*arr[i];
    }

    // Sorting the whole array
    sort(arr,arr+n);

    // Finding the middle value of
    // the array
    int mid=(n-1)/2;

    // Reverting the changed sign
    for (int i = 0; i <= mid; i++) {
            arr[i]=-1*arr[i];
    }

    // Reverse first half of array
    reverse(arr,arr+mid+1);
    // Reverse second half of array
    reverse(arr+mid+1,arr+n);
}

// Driver Program
int main()
{
    int arr[] = { 1, 5, 8, 9, 6, 7, 3, 4, 2, 0 };
    int n = sizeof(arr) / sizeof(arr[0]);
    bitonicGenerator(arr, n);
    for (int i = 0; i < n; i++)
        cout << arr[i] << " ";
    return 0;
}

// This code is contributed by Pushpesh Raj.

Java

// Java Program to sort even-placed elements in increasing and
// odd-placed in decreasing order with constant space complexity
import java.util.Arrays;

public class GFG {

static void reverse(int a[], int l,int r)
{
    while(l<=r)
    {
        int temp = a[l];
        a[l] = a[r];
        a[r] = temp;
        l++;
        r--;
    }
}


static void bitonicGenerator(int[] arr, int n)
{
    // Making all even placed index
    // element negative
    for (int i = 0; i < n; i++) {
        if (i % 2==0)
            arr[i]=-1*arr[i];
    }

    // Sorting the whole array
    Arrays.sort(arr);

    // Finding the middle value of
    // the array
    int mid=(n-1)/2;

    // Reverting the changed sign
    for (int i = 0; i <= mid; i++) {
            arr[i]=-1*arr[i];
    }

    // Reverse first half of array
    reverse(arr,0,mid);
    // Reverse second half of array
    reverse(arr,mid+1,n-1);

}

    // Driver Code
    public static void main (String[] args)
    {
        int arr[] = { 1, 5, 8, 9, 6, 7, 3, 4, 2, 0 };
        int n = arr.length;
        bitonicGenerator(arr, n);
        for (int i = 0; i < n; i++)
        System.out.print(arr[i]+" ");
    }
}
// This code is contributed by aditya942003patil

Python3

class GFG :
    @staticmethod
    def reverse( a,  l,  r) :
        while (l <= r) :
            temp = a[l]
            a[l] = a[r]
            a[r] = temp
            l += 1
            r -= 1
    @staticmethod
    def bitonicGenerator( arr,  n) :

        # Making all even placed index
        # element negative
        i = 0
        while (i < n) :
            if (i % 2 == 0) :
                arr[i] = -1 * arr[i]
            i += 1

        # Sorting the whole array
        arr.sort()

        # Finding the middle value of
        # the array
        mid = int((n - 1) / 2)

        # Reverting the changed sign
        i = 0
        while (i <= mid) :
            arr[i] = -1 * arr[i]
            i += 1

        # Reverse first half of array
        GFG.reverse(arr, 0, mid)

        # Reverse second half of array
        GFG.reverse(arr, mid + 1, n - 1)

    # Driver Code
    @staticmethod
    def main( args) :
        arr = [1, 5, 8, 9, 6, 7, 3, 4, 2, 0]
        n = len(arr)
        GFG.bitonicGenerator(arr, n)
        i = 0
        while (i < n) :
            print(str(arr[i]) + " ", end ="")
            i += 1


if __name__=="__main__":
    GFG.main([])

    # This code is contributed by aadityaburujwale.

C#

// Include namespace system
using System;
using System.Linq;
using System.Collections;

public class GFG
{
  public static void reverse(int[] a, int l, int r)
  {
    while (l <= r)
    {
      var temp = a[l];
      a[l] = a[r];
      a[r] = temp;
      l++;
      r--;
    }
  }
  public static void bitonicGenerator(int[] arr, int n)
  {

    // Making all even placed index
    // element negative
    for (int i = 0; i < n; i++)
    {
      if (i % 2 == 0)
      {
        arr[i] = -1 * arr[i];
      }
    }

    // Sorting the whole array
    Array.Sort(arr);

    // Finding the middle value of
    // the array
    var mid = (int)((n - 1) / 2);

    // Reverting the changed sign
    for (int i = 0; i <= mid; i++)
    {
      arr[i] = -1 * arr[i];
    }

    // Reverse first half of array
    GFG.reverse(arr, 0, mid);

    // Reverse second half of array
    GFG.reverse(arr, mid + 1, n - 1);
  }

  // Driver Code
  public static void Main(String[] args)
  {
    int[] arr = {1, 5, 8, 9, 6, 7, 3, 4, 2, 0};
    var n = arr.Length;
    GFG.bitonicGenerator(arr, n);
    for (int i = 0; i < n; i++)
    {
      Console.Write(arr[i].ToString() + " ");
    }
  }
}

// This code is contributed by aadityaburujwale.

Javascript

function reverse(a, l, r)
{
    while (l <= r)
    {
        var temp = a[l];
        a[l] = a[r];
        a[r] = temp;
        l++;
        r--;
    }
}
function bitonicGenerator(arr, n)
{
    // Making all even placed index
    // element negative
    var i=0;
    for (i; i < n; i++)
    {
        if (i % 2 == 0)
        {
            arr[i] = -1 * arr[i];
        }
    }

    // Sorting the whole array
    arr.sort(function(a, b) {return a - b;});

    // Finding the middle value of
    // the array
    var mid = parseInt((n - 1) / 2);

    // Reverting the changed sign
    var i=0;
    for (i; i <= mid; i++)
    {
        arr[i] = -1 * arr[i];
    }

    // Reverse first half of array
    reverse(arr, 0, mid);

    // Reverse second half of array
    reverse(arr, mid + 1, n - 1);
}

// Driver Code
    var arr = [1, 5, 8, 9, 6, 7, 3, 4, 2, 0];
    var n = arr.length;
    bitonicGenerator(arr, n);
    var i = 0;
    for (i; i < n; i++)
    {
        console.log(arr[i] + " ");
    }

    // This code is contributed by sourabhdalal0001.

Output

1 2 3 6 8 9 7 5 4 0 

Time Complexity: O(n*log(n)) 
Auxiliary Space: O(1)