# Insertion sort to sort even and odd positioned elements in different orders

We are given an array. We need to sort the even positioned elements in the ascending order and the odd positioned elements in the descending order. We must apply insertion sort to sort them.

Examples:

```Input : a[] = {7, 10, 11, 3, 6, 9, 2, 13, 0}
Output :      11  3   7  9  6  10  2  13  0
Even positioned elements after sorting int
ascending order : 3 9 10 13
Odd positioned elements after sorting int
descending order : 11 7 6 2 0
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

We separately apply the insertion sort technique on the even positioned elements and the odd positioned elements separately but within the same array. The loop starts for the odd positioned from the 0th index(1st element) and the for the even from the 1st index(2nd element) and keep on increasing by 2 since every alternate is odd/even positioned.
We now simply apply the insertion sort procedure on the odd positioned and even positioned. the odd positioned elements are A[0, 2, 4, …] and even are A[1, 3, 5, 7..]. So they are considered as separate sub-arrays but within the same array.
Explanation for the odd positioned:

The 0th element already sorted. Now the 2nd element compared with the 0th and inserted and so on the (i+2)th element compared with the previous ones until the end of the array. The same approach is applied for the even positioned elements in
the array.(This is same as the insertion sort technique).

 `// C++ program to sort even positioned elements ` `// in ascending order and odd positioned ` `// elements in descending order. ` `#include ` `#include ` ` `  `// Function to calculate the given problem. ` `void` `evenOddInsertionSort(``int` `arr[], ``int` `n) ` `{ ` `  ``for` `(``int` `i = 2; i < n; i++) ` `  ``{ ` `      ``int` `j = i-2; ` `      ``int` `temp = arr[i]; ` `         `  `      ``/* checking whether the position is even  ` `        ``or odd. And after checking applying the  ` `        ``insertion sort to the given  ` `        ``positioned elements.*/`     `     `  `      ``// checking for odd positioned. ` `      ``if` `((i+1) & 1 == 1)  ` `      ``{ ` `         ``// Inserting even positioned elements ` `         ``// in ascending order. ` `         ``while` `(temp >= arr[j] && j >= 0)  ` `         ``{ ` `            ``arr[j+2] = arr[j]; ` `            ``j -= 2; ` `         ``} ` `         ``arr[j+2] = temp;             ` `      ``} ` `     `  `     ``// sorting the even positioned. ` `     ``else` `{ ` ` `  `         ``// Inserting odd positioned elements ` `         ``// in descending order. ` `         ``while` `(temp <= arr[j] && j >= 0)  ` `         ``{ ` `            ``arr[j+2] = arr[j]; ` `           ``j -= 2; ` `         ``} ` `         ``arr[j+2] = temp;    ` `      ``} ` `   ``} ` `} ` ` `  `// A utility function to print an array of size n ` `void` `printArray(``int` `arr[], ``int` `n) ` `{ ` `    ``for` `(``int` `i=0; i < n; i++) ` `        ``printf``(``"%d "``, arr[i]); ` `    ``printf``(``"\n"``); ` `} ` ` `  `/* Driver program to test insertion sort */` `int` `main() ` `{ ` `    ``int` `arr[] = {12, 11, 13, 5, 6}; ` `    ``int` `n = ``sizeof``(arr)/``sizeof``(arr[0]); ` ` `  `    ``evenOddInsertionSort(arr, n); ` `    ``printArray(arr, n); ` ` `  `    ``return` `0; ` `} `

 `// Java program to sort even positioned elements  ` `// in ascending order and odd positioned  ` `// elements in descending order. ` ` `  `class` `GFG  ` `{ ` ` `  `    ``// Function to calculate the given problem.  ` `    ``static` `void` `evenOddInsertionSort(``int` `arr[], ``int` `n)  ` `    ``{ ` `        ``for` `(``int` `i = ``2``; i < n; i++) ` `        ``{ ` `            ``int` `j = i - ``2``; ` `            ``int` `temp = arr[i]; ` ` `  `            ``/* checking whether the position is even  ` `            ``or odd. And after checking applying the  ` `            ``insertion sort to the given  ` `            ``positioned elements.*/` `            ``// checking for odd positioned.  ` `            ``if` `(((i + ``1``) & ``1``) == ``1``) ` `            ``{ ` `                ``// Inserting even positioned elements  ` `                ``// in ascending order.  ` `                ``while` `(j >= ``0` `&& temp >= arr[j]) ` `                ``{ ` `                    ``arr[j + ``2``] = arr[j]; ` `                    ``j -= ``2``; ` `                ``} ` `                ``arr[j + ``2``] = temp; ` `            ``}  ` `             `  `            ``// sorting the even positioned.  ` `            ``else` `            ``{ ` ` `  `                ``// Inserting odd positioned elements  ` `                ``// in descending order.  ` `                ``while` `(j >= ``0` `&& temp <= arr[j]) ` `                ``{ ` `                    ``arr[j + ``2``] = arr[j]; ` `                    ``j -= ``2``; ` `                ``} ` `                ``arr[j + ``2``] = temp; ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``// A utility function to print an array of size n  ` `    ``static` `void` `printArray(``int` `arr[], ``int` `n) ` `    ``{ ` `        ``for` `(``int` `i = ``0``; i < n; i++)  ` `        ``{ ` `            ``System.out.printf(``"%d "``, arr[i]); ` `        ``} ` `        ``System.out.printf(``"\n"``); ` `    ``} ` ` `  `    ``/* Driver program to test insertion sort */` `    ``public` `static` `void` `main(String[] args) ` `    ``{ ` `        ``int` `arr[] = {``12``, ``11``, ``13``, ``5``, ``6``}; ` `        ``int` `n = arr.length; ` ` `  `        ``evenOddInsertionSort(arr, n); ` `        ``printArray(arr, n); ` `    ``} ` `} ` ` `  `// This code contributed by Rajput-Ji `

 `# Python3 program to sort even ` `# positioned elements in ascending  ` `# order and odd positionedelements  ` `# in descending order. ` ` `  `# Function to calculate  ` `# the given problem. ` `def` `evenOddInsertionSort(arr, n): ` ` `  `    ``for` `i ``in` `range``(``2``, n): ` `     `  `        ``j ``=` `i ``-` `2` `        ``temp ``=` `arr[i] ` `             `  `        ``# checking whether the position ` `        ``#  is even or odd. And after  ` `        ``# checking applying the insertion  ` `        ``# sort to the given  ` `        ``# positioned elements. ` `         `  `        ``# checking for odd positioned. ` `        ``if` `((i ``+` `1``) & ``1` `=``=` `1``) : ` `         `  `            ``# Inserting even positioned elements ` `            ``# in ascending order. ` `            ``while` `(temp >``=` `arr[j] ``and` `j >``=` `0``):  ` `             `  `                ``arr[j ``+` `2``] ``=` `arr[j] ` `                ``j ``-``=` `2` `             `  `            ``arr[j ``+` `2``] ``=` `temp      ` `         `  `         `  `        ``# sorting the even positioned. ` `        ``else` `: ` `     `  `            ``# Inserting odd positioned elements ` `            ``# in descending order. ` `            ``while` `(temp <``=` `arr[j] ``and` `j >``=` `0``) : ` `             `  `                ``arr[j ``+` `2``] ``=` `arr[j] ` `                ``j ``-``=` `2` `             `  `            ``arr[j ``+` `2``] ``=` `temp  ` `         `  `     `  `     `  `     `  `# A utility function to print an array of size n ` `def` `printArray(arr, n): ` `     `  `    ``for` `i ``in` `range``(``0``, n): ` `            ``print``(arr[i], end``=``" "``) ` ` `  `# Driver program  ` `arr ``=` `[``12``, ``11``, ``13``, ``5``, ``6``] ` `n ``=` `len``(arr) ` `evenOddInsertionSort(arr, n) ` `printArray(arr, n) ` ` `  ` `  `# This code is contributed by ` `# Smitha Dinesh Semwal `

 `// C# program to sort even positioned elements  ` `// in ascending order and odd positioned  ` `// elements in descending order. ` `using` `System; ` ` `  `class` `GFG  ` `{ ` ` `  `    ``// Function to calculate the given problem.  ` `    ``static` `void` `evenOddInsertionSort(``int` `[]arr, ``int` `n)  ` `    ``{ ` `        ``for` `(``int` `i = 2; i < n; i++) ` `        ``{ ` `            ``int` `j = i - 2; ` `            ``int` `temp = arr[i]; ` ` `  `            ``/* checking whether the position is even  ` `            ``or odd. And after checking applying the  ` `            ``insertion sort to the given  ` `            ``positioned elements.*/` `            ``// checking for odd positioned.  ` `            ``if` `(((i + 1) & 1) == 1) ` `            ``{ ` `                ``// Inserting even positioned elements  ` `                ``// in ascending order.  ` `                ``while` `(j >= 0 && temp >= arr[j]) ` `                ``{ ` `                    ``arr[j + 2] = arr[j]; ` `                    ``j -= 2; ` `                ``} ` `                ``arr[j + 2] = temp; ` `            ``}  ` `             `  `            ``// sorting the even positioned.  ` `            ``else` `            ``{ ` ` `  `                ``// Inserting odd positioned elements  ` `                ``// in descending order.  ` `                ``while` `(j >= 0 && temp <= arr[j]) ` `                ``{ ` `                    ``arr[j + 2] = arr[j]; ` `                    ``j -= 2; ` `                ``} ` `                ``arr[j + 2] = temp; ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``// A utility function to print an array of size n  ` `    ``static` `void` `printArray(``int` `[]arr, ``int` `n) ` `    ``{ ` `        ``for` `(``int` `i = 0; i < n; i++)  ` `        ``{ ` `            ``Console.Write(``"{0} "``, arr[i]); ` `        ``} ` `        ``Console.Write(``"\n"``); ` `    ``} ` ` `  `    ``/* Driver code */` `    ``public` `static` `void` `Main(String[] args) ` `    ``{ ` `        ``int` `[]arr = {12, 11, 13, 5, 6}; ` `        ``int` `n = arr.Length; ` ` `  `        ``evenOddInsertionSort(arr, n); ` `        ``printArray(arr, n); ` `    ``} ` `} ` ` `  `// This code has been contributed by 29AjayKumar `

Output:

```13 5 12 11 6
```

There exist better approaches to solve this problem without insertion sort. Please refer Sort even-placed elements in increasing and odd-placed in decreasing order for details.

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.

ALGORITHM AND DATA STUCTURES

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Improved By : Rajput-Ji, 29AjayKumar

Article Tags :
Practice Tags :