# Rearrange sorted array such that all odd indices elements comes before all even indices element

• Difficulty Level : Expert
• Last Updated : 05 Oct, 2021

Given a sorted array arr[] consisting of N positive integers, the task is to rearrange the array such that all the odd indices elements come before all the even indices elements.

Examples:

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Input: arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9}
Output: 2 4 6 8 1 3 5 7 9

Input: arr[] = {0, 3, 7, 7, 10}
Output: 3 7 0 7 10

Approach: The given problem can be solved by modifying the given array by taking the value (maximum array element + 1) as the pivot(say) and then for the first half of the array add the value (arr[oddIndex]%pivot)*pivot at the odd indices oddIndex and for the second half of the array add the value (arr[evenIndex]%pivot)*pivot at the even indices evenIndex. After the above steps, divide each array element by the value of pivot. Below is the illustration for the same:

Consider the array arr[] = {3, 7}, then the value of pivot is 7 + 1 = 8.

For the first half:
Modify the array element arr = 3 + (7%8)*8 = 3+ 56 = 59.

For the second half:

Modify the array element arr = 7 + (59%8)*8 = 7 + 24 = 31.

Dividing each array element by the pivot  modifies the array to {7, 3} which is the required result.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `// Function to print the array``void` `printTheArray(``int` `arr[], ``int` `N)``{``  ``for` `(``int` `i = 0; i < N; i++)``    ``cout << arr[i] << ``" "``;``}` `// Function to rearrange the array such``// that odd indexed elements come before``// even indexed elements``void` `rearrange(``int` `arr[], ``int` `N)``{``  ``//Reduces the size of array by one``  ``//because last element does not need``  ``//to be changed in case N = odd``  ``if` `(N & 1)``    ``N--;` `  ``// Initialize the variables``  ``int` `odd_idx = 1, even_idx = 0;` `  ``int` `i, max_elem = arr[N - 1] + 1;` `  ``// Iterate over the range``  ``for` `(i = 0; i < N / 2; i++) {` `    ``// Add the modified element at``    ``// the odd position``    ``arr[i] += (arr[odd_idx] % max_elem) * max_elem;` `    ``odd_idx += 2;``  ``}` `  ``// Iterate over the range``  ``for` `(; i < N; i++) {` `    ``// Add the modified element at``    ``// the even position``    ``arr[i] += (arr[even_idx] % max_elem) * max_elem;` `    ``even_idx += 2;``  ``}` `  ``// Iterate over the range``  ``for` `(``int` `i = 0; i < N; i++) {` `    ``// Divide by thr maximum element``    ``arr[i] = arr[i] / max_elem;``  ``}``}` `// Driver Code``int` `main()``{``  ``int` `arr[] = { 1, 2, 3, 4, 5, 16, 18, 19 };``  ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);``  ` `  ``rearrange(arr, N);``  ``printTheArray(arr, N);` `  ``return` `0;``}` `//This code is contributed by Akash Jha`

## Java

 `// Java program for the above approach``import` `java.io.*;` `class` `GFG``{` `// Function to print the array``static` `void` `printTheArray(``int` `arr[], ``int` `N)``{``  ``for` `(``int` `i = ``0``; i < N; i++)``   ``System.out.print(arr[i] + ``" "``);``}` `// Function to rearrange the array such``// that odd indexed elements come before``// even indexed elements``static` `void` `rearrange(``int` `arr[], ``int` `N)``{``  ` `  ``// Reduces the size of array by one``  ``// because last element does not need``  ``// to be changed in case N = odd``  ``if` `((N & ``1``) != ``0``)``    ``N--;` `  ``// Initialize the variables``  ``int` `odd_idx = ``1``, even_idx = ``0``;` `  ``int` `i, max_elem = arr[N - ``1``] + ``1``;` `  ``// Iterate over the range``  ``for` `(i = ``0``; i < N / ``2``; i++) {` `    ``// Add the modified element at``    ``// the odd position``    ``arr[i] += (arr[odd_idx] % max_elem) * max_elem;` `    ``odd_idx += ``2``;``  ``}` `  ``// Iterate over the range``  ``for` `(; i < N; i++) {` `    ``// Add the modified element at``    ``// the even position``    ``arr[i] += (arr[even_idx] % max_elem) * max_elem;` `    ``even_idx += ``2``;``  ``}` `  ``// Iterate over the range``  ``for` `(i = ``0``; i < N; i++) {` `    ``// Divide by thr maximum element``    ``arr[i] = arr[i] / max_elem;``  ``}``}` `// Driver Code``public` `static` `void` `main (String[] args)``{``     ``int` `arr[] = { ``1``, ``2``, ``3``, ``4``, ``5``, ``16``, ``18``, ``19` `};``    ``int` `N = arr.length;``  ` `    ``rearrange(arr, N);``    ``printTheArray(arr, N);` `}``}` `// This code is contributed by avijitmondal1998.`

## Python3

 `# Python program for the above approach` `# Function to print the array``def` `printArray(arr, n):``  ``for` `i ``in` `range``(N):``    ``print``(arr[i],end``=``" "``)``  ``print``(``"\n"``)`  `# Function to rearrange the array such``# that odd indexed elements come before``# even indexed elements``def` `rearrange(arr, N):``  ` `  ``#Reduces the size of array by one``  ``#because last element does not need``  ``#to be changed in case N = odd``  ``if` `(N & ``1``):``    ``N``-``=``1` `  ``# Initialize the variables``  ``odd_idx ``=` `1``  ``even_idx ``=` `0``  ``max_elem ``=` `arr[N ``-` `1``] ``+` `1` `  ``# Iterate over the range``  ``for` `i ``in` `range``(N``/``/``2``):` `    ``# Add the modified element at``    ``# the odd position``    ``arr[i] ``+``=` `(arr[odd_idx] ``%` `max_elem) ``*` `max_elem``    ``odd_idx ``+``=` `2``  `  `  ``# Iterate over the range``  ``for` `i ``in` `range``(N``/``/``2``,N):` `    ``# Add the modified element at``    ``# the even position``    ``arr[i] ``+``=` `(arr[even_idx] ``%` `max_elem) ``*` `max_elem``    ``even_idx ``+``=` `2``  `  `  ``# Iterate over the range``  ``for` `i ``in` `range``(N):` `    ``# Divide by the maximum element``    ``arr[i] ``=` `arr[i] ``/``/` `max_elem``  `    `# Driver Code``if` `__name__``=``=``"__main__"``:``  ` `  ``arr ``=` `[ ``1``, ``2``, ``3``, ``4``, ``5``, ``16``, ``18``, ``19` `]``  ``N ``=` `len``(arr)``  ` `  ``rearrange(arr, N)``  ``printArray(arr, N);` `#This code is contributed by Akash Jha`

## C#

 `// C# program for the above approach``using` `System;``using` `System.Collections.Generic;` `class` `GFG{` `// Function to print the array``static` `void` `printTheArray(``int` `[]arr, ``int` `N)``{``  ``for` `(``int` `i = 0; i < N; i++)``    ``Console.Write(arr[i]+``" "``);``}` `// Function to rearrange the array such``// that odd indexed elements come before``// even indexed elements``static` `void` `rearrange(``int` `[]arr, ``int` `N)``{``  ``// Reduces the size of array by one``  ``// because last element does not need``  ``// to be changed in case N = odd``  ``if` `((N & 1) != 0)``    ``N--;` `  ``// Initialize the variables``  ``int` `odd_idx = 1, even_idx = 0;` `  ``int` `i, max_elem = arr[N - 1] + 1;` `  ``// Iterate over the range``  ``for` `(i = 0; i < N / 2; i++) {` `    ``// Add the modified element at``    ``// the odd position``    ``arr[i] += (arr[odd_idx] % max_elem) * max_elem;` `    ``odd_idx += 2;``  ``}` `  ``// Iterate over the range``  ``for` `(; i < N; i++) {` `    ``// Add the modified element at``    ``// the even position``    ``arr[i] += (arr[even_idx] % max_elem) * max_elem;` `    ``even_idx += 2;``  ``}` `  ``// Iterate over the range``  ``for``(i = 0; i < N; i++) {` `    ``// Divide by thr maximum element``    ``arr[i] = arr[i] / max_elem;``  ``}``}` `// Driver Code``public` `static` `void` `Main()``{``  ``int` `[]arr = { 1, 2, 3, 4, 5, 16, 18, 19};``  ``int` `N = arr.Length;``  ` `  ``rearrange(arr, N);``  ``printTheArray(arr, N);``}``}` `// This code is contributed by SURENDRA_GANGWAR.`

## Javascript

 ``
Output:
`2 4 16 19 1 3 5 18`

Time Complexity: O(N)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up