Open In App

# Sort all even numbers in ascending order and then sort all odd numbers in descending order

Given an array of integers (both odd and even), sort them in such a way that the first part of the array contains odd numbers sorted in descending order, rest portion contains even numbers sorted in ascending order.
Examples:

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

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

Naive Approach-

The idea is to store all even in a separate array or vector and sort them in ascending order and then store all odd in a separate array or vector and sort them in descending order. Then replace all input array elements with those odd array/vector elements followed by even array/vector elements

Steps to implement-

• Declare two vectors odd and even to store odd and even elements
• Run a for loop on the input array to separately store odd and even elements into odd and even vector
• Then sort even elements in ascending order and odd elements in decreasing order
• Then, first copy odd elements into the original array and then even elements into that array

Code-

## C++

 `// C++ program sort array in even and odd manner.``// The odd numbers are to be sorted in descending``// order and the even numbers in ascending order``#include ``using` `namespace` `std;`` ` `// To do two way sort. First sort even numbers in``// ascending order, then odd numbers in descending``// order.``void` `twoWaySort(``int` `arr[], ``int` `n)``{``    ``//To store odd Numbers``    ``vector<``int``> odd;``     ` `    ``//To store Even Numbers``    ``vector<``int``> even;``     ` `    ``for``(``int` `i=0;i());``         ` `       ` `      ``int` `i=0;``       ` `      ``//First store odd numbers to array``      ``for``(``int` `j=0;j

## Java

 `// Java program sort array in even and odd manner.``// The odd numbers are to be sorted in descending``// order and the even numbers in ascending order``import` `java.util.Arrays;``import` `java.util.Collections;``import` `java.util.List;``import` `java.util.ArrayList;`` ` `public` `class` `Main {``    ``// To do two way sort. ``   ``// First sort even numbers in ascending order, ``  ``// then odd numbers in descending order.``    ``public` `static` `void` `twoWaySort(``int``[] arr) {``        ``// To store odd Numbers``        ``List odd = ``new` `ArrayList<>();`` ` `        ``// To store Even Numbers``        ``List even = ``new` `ArrayList<>();`` ` `        ``for` `(``int` `i = ``0``; i < arr.length; i++) {``            ``// If number is even, push them to the even list``            ``if` `(arr[i] % ``2` `== ``0``) {``                ``even.add(arr[i]);``            ``}``            ``// If number is odd, push them to the odd list``            ``else` `{``                ``odd.add(arr[i]);``            ``}``        ``}`` ` `        ``// Sort even list in ascending order``        ``Collections.sort(even);`` ` `        ``// Sort odd list in descending order``        ``Collections.sort(odd, Collections.reverseOrder());`` ` `        ``int` `i = ``0``;`` ` `        ``// First store odd numbers in the array``        ``for` `(``int` `j = ``0``; j < odd.size(); j++) {``            ``arr[i] = odd.get(j);``            ``i++;``        ``}`` ` `        ``// Then store even numbers in the array``        ``for` `(``int` `j = ``0``; j < even.size(); j++) {``            ``arr[i] = even.get(j);``            ``i++;``        ``}``    ``}`` ` `    ``// Driver code``    ``public` `static` `void` `main(String[] args) {``        ``int``[] arr = { ``1``, ``3``, ``2``, ``7``, ``5``, ``4` `};``        ``twoWaySort(arr);``        ``for` `(``int` `i = ``0``; i < arr.length; i++) {``            ``System.out.print(arr[i] + ``" "``);``        ``}``    ``}``}`

## Python3

 `def` `twoWaySort(arr, n):``    ``# To store odd Numbers``    ``odd ``=` `[]``    ``# To store Even Numbers``    ``even ``=` `[]``    ``for` `i ``in` `range``(n):``        ``# If number is even push them to even vector``        ``if` `arr[i] ``%` `2` `=``=` `0``:``            ``even.append(arr[i])``        ``# If number is odd push them to odd vector``        ``else``:``            ``odd.append(arr[i])``    ``# Sort even array in ascending order``    ``even.sort()``    ``# Sort odd array in descending order``    ``odd.sort(reverse``=``True``)``    ``i ``=` `0``    ``# First store odd numbers to array``    ``for` `j ``in` `range``(``len``(odd)):``        ``arr[i] ``=` `odd[j]``        ``i ``+``=` `1``    ``# Then store even numbers to array``    ``for` `j ``in` `range``(``len``(even)):``        ``arr[i] ``=` `even[j]``        ``i ``+``=` `1`` ` ` ` `arr ``=` `[``1``, ``3``, ``2``, ``7``, ``5``, ``4``]``n ``=` `len``(arr)``twoWaySort(arr, n)``for` `i ``in` `range``(n):``    ``print``(arr[i], end``=``" "``)`

## C#

 `// C# program sort array in even and odd manner.``// The odd numbers are to be sorted in descending``// order and the even numbers in ascending order``using` `System;``using` `System.Collections.Generic;``using` `System.Linq;`` ` `class` `Program {``    ``// To do two-way sort. First sort even numbers in``    ``// ascending order, then odd numbers in descending``    ``// order.``    ``static` `void` `TwoWaySort(``int``[] arr, ``int` `n)``    ``{``        ``// To store odd numbers``        ``List<``int``> odd = ``new` `List<``int``>();`` ` `        ``// To store even numbers``        ``List<``int``> even = ``new` `List<``int``>();`` ` `        ``for` `(``int` `i = 0; i < n; i++) {``            ``// If number is even, push them to even list``            ``if` `(arr[i] % 2 == 0) {``                ``even.Add(arr[i]);``            ``}``            ``// If number is odd, push them to odd list``            ``else` `{``                ``odd.Add(arr[i]);``            ``}``        ``}`` ` `        ``// Sort even list in ascending order``        ``even.Sort();`` ` `        ``// Sort odd list in descending order``        ``odd.Sort();``        ``odd.Reverse();`` ` `        ``int` `index = 0;`` ` `        ``// First store odd numbers in the array``        ``foreach``(``int` `number ``in` `odd)``        ``{``            ``arr[index] = number;``            ``index++;``        ``}`` ` `        ``// Then store even numbers in the array``        ``foreach``(``int` `number ``in` `even)``        ``{``            ``arr[index] = number;``            ``index++;``        ``}``    ``}`` ` `    ``// Driver code``    ``static` `void` `Main(``string``[] args)``    ``{``        ``int``[] arr = { 1, 3, 2, 7, 5, 4 };``        ``int` `n = arr.Length;``        ``TwoWaySort(arr, n);``        ``for` `(``int` `i = 0; i < n; i++) {``            ``Console.Write(arr[i] + ``" "``);``        ``}``    ``}``}`` ` `// This code is contributed by akshitaguprzj3`

## Javascript

 `// Javascript program sort array in even and odd manner.``// The odd numbers are to be sorted in descending``// order and the even numbers in ascending order`` ` `// Function to do two-way sort.``// First sort even numbers in ascending order,``// then odd numbers in descending order.``function` `twoWaySort(arr) {``  ``// To store odd numbers``  ``let odd = [];``   ` `  ``// To store even numbers``  ``let even = [];``   ` `  ``for` `(let i = 0; i < arr.length; i++) {``    ``// If number is even, push it to the even list``    ``if` `(arr[i] % 2 === 0) {``      ``even.push(arr[i]);``    ``}``    ``// If number is odd, push it to the odd list``    ``else` `{``      ``odd.push(arr[i]);``    ``}``  ``}``   ` `  ``// Sort the even list in ascending order``  ``even.sort((a, b) => a - b);``   ` `  ``// Sort the odd list in descending order``  ``odd.sort((a, b) => b - a);``   ` `  ``let index = 0;``   ` `  ``// First, store the odd numbers in the array``  ``for` `(let j = 0; j < odd.length; j++) {``    ``arr[index] = odd[j];``    ``index++;``  ``}``   ` `  ``// Then, store the even numbers in the array``  ``for` `(let j = 0; j < even.length; j++) {``    ``arr[index] = even[j];``    ``index++;``  ``}``}`` ` `// Driver code``let arr = [1, 3, 2, 7, 5, 4];``twoWaySort(arr);``console.log(arr.join(``" "``));`` ` ` ` `// This code is contributed by shivamgupta0987654321`

Output

```7 5 3 1 2 4

```

Time complexity: O(n + n log n) , for sorting even vector and odd vector and running a for loop
Auxiliary Space: O(n), because there are in total n elements in both the vector

Method 1 (Using Partition)

1. Partition the input array such that all odd elements are moved to the left and all even elements on right. This step takes O(n).
2. Once the array is partitioned, sort left and right parts individually. This step takes O(n Log n).

Follow the below steps to implement the above idea:

• Initialize two variables l and r to 0 and n-1 respectively.
• Initialize a variable k to 0 which will count the number of odd elements in the array.
• Run a loop while l < r:
a. Find the first even number from the left side of the array by checking if arr[l] is even, if not increment l and k by 1.
b. Find the first odd number from the right side of the array by checking if arr[r] is odd, if not decrement r by 1.
c. Swap the even number at index l with the odd number at index r.
• Sort the first k elements of the array in descending order using the in-built sort function with greater<int>() as the comparator.
• Sort the remaining n-k elements of the array in ascending order using the in-built sort function.
• The sorted array is now ready to be printed.

Below is the implementation of the above idea.

## C++

 `// C++ program sort array in even and odd manner.``// The odd numbers are to be sorted in descending``// order and the even numbers in ascending order``#include ``using` `namespace` `std;`` ` `// To do two way sort. First sort even numbers in``// ascending order, then odd numbers in descending``// order.``void` `twoWaySort(``int` `arr[], ``int` `n)``{``     ` `    ``// Current indexes from left and right``    ``int` `l = 0, r = n - 1;`` ` `    ``// Count of odd numbers``    ``int` `k = 0;`` ` `    ``while` `(l < r) ``    ``{``     ` `        ``// Find first even number ``        ``// from left side.``        ``while` `(arr[l] % 2 != 0) ``        ``{``            ``l++;``            ``k++;``        ``}`` ` `        ``// Find first odd number ``        ``// from right side.``        ``while` `(arr[r] % 2 == 0 && l < r)``            ``r--;`` ` `        ``// Swap even number present on left and odd``        ``// number right.``        ``if` `(l < r)``            ``swap(arr[l], arr[r]);``    ``}`` ` `    ``// Sort odd number in descending order``    ``sort(arr, arr + k, greater<``int``>());`` ` `    ``// Sort even number in ascending order``    ``sort(arr + k, arr + n);``}`` ` `// Driver code``int` `main()``{``    ``int` `arr[] = { 1, 3, 2, 7, 5, 4 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(``int``);``    ``twoWaySort(arr, n);``    ``for` `(``int` `i = 0; i < n; i++)``        ``cout << arr[i] << ``" "``;``    ``return` `0;``}`

## Java

 `// Java program sort array in even and odd manner.``// The odd numbers are to be sorted in descending``// order and the even numbers in ascending order`` ` `import` `java.util.Arrays;``import` `java.util.Collections;`` ` `public` `class` `GFG {``    ``// To do two way sort. First sort even numbers in``    ``// ascending order, then odd numbers in descending``    ``// order.``    ``static` `void` `twoWaySort(Integer arr[], ``int` `n)``    ``{``        ``// Current indexes from left and right``        ``int` `l = ``0``, r = n - ``1``;`` ` `        ``// Count of odd numbers``        ``int` `k = ``0``;`` ` `        ``while` `(l < r) ``        ``{``         ` `            ``// Find first even number from left side.``            ``while` `(arr[l] % ``2` `!= ``0``) ``            ``{``                ``l++;``                ``k++;``            ``}`` ` `            ``// Find first odd number from right side.``            ``while` `(arr[r] % ``2` `== ``0` `&& l < r)``                ``r--;`` ` `            ``// Swap even number present on left and odd``            ``// number right.``            ``if` `(l < r) ``            ``{``             ` `                ``// swap arr[l] arr[r]``                ``int` `temp = arr[l];``                ``arr[l] = arr[r];``                ``arr[r] = temp;``            ``}``        ``}`` ` `        ``// Sort odd number in descending order``        ``Arrays.sort(arr, ``0``, k, Collections.``                                  ``reverseOrder());`` ` `        ``// Sort even number in ascending order``        ``Arrays.sort(arr, k, n);``    ``}`` ` `    ``// Driver Method``    ``public` `static` `void` `main(String[] args)``    ``{``        ``Integer arr[] = { ``1``, ``3``, ``2``, ``7``, ``5``, ``4` `};`` ` `        ``twoWaySort(arr, arr.length);`` ` `        ``System.out.println(Arrays.toString(arr));``    ``}``}`

## Python

 `# Python program to sort array ``# in even and odd manner ``# The odd numbers are to be ``# sorted in descending order ``# and the even numbers in ``# ascending order`` ` `# To do two way sort. First ``# sort even numbers in ascending``# order, then odd numbers in ``# descending order.``def` `two_way_sort(arr, arr_len):``     ` `    ``# Current indexes l->left``    ``# and r->right``    ``l, r ``=` `0``, arr_len ``-` `1``     ` `    ``# Count of number of ``    ``# odd numbers, used in``    ``# slicing the array later.``    ``k ``=` `0``     ` `    ``# Run till left(l) < right(r)``    ``while``(l < r):``         ` `        ``# While left(l) is odd, if yes``        ``# increment the left(l) plus ``        ``# odd count(k) if not break the``        ``# while for even number found ``        ``# here to be swapped``        ``while``(arr[l] ``%` `2` `!``=` `0``):``            ``l ``+``=` `1``            ``k ``+``=` `1``             ` `        ``# While right(r) is even, ``        ``# if yes decrement right(r)``        ``# if not break the while for ``        ``# odd number found here to``        ``# be swapped     ``        ``while``(arr[r] ``%` `2` `=``=` `0` `and` `l < r):``            ``r ``-``=` `1``             ` `        ``# Swap the left(l) and right(r), ``        ``# which is even and odd numbers ``        ``# encountered in above loops``        ``if``(l < r):``            ``arr[l], arr[r] ``=` `arr[r], arr[l]``             ` `    ``# Slice the number on the``    ``# basis of odd count(k)``    ``odd ``=` `arr[:k]``    ``even ``=` `arr[k:]``     ` `    ``# Sort the odd and ``    ``# even array accordingly``    ``odd.sort(reverse ``=` `True``)``    ``even.sort()``     ` `    ``# Extend the odd array with ``    ``# even values and return it.``    ``odd.extend(even)``     ` `    ``return` `odd``     ` `# Driver code``arr_len ``=` `6``arr ``=` `[``1``, ``3``, ``2``, ``7``, ``5``, ``4``]``result ``=` `two_way_sort(arr, arr_len)``for` `i ``in` `result:``    ``print``(``str``(i) ``+` `" "``),`` ` `# This code is contributed ``# by JaySiyaRam`

## C#

 `// C# program sort array in even and odd manner.``// The odd numbers are to be sorted in descending``// order and the even numbers in ascending order``using` `System;``using` `System.Linq;`` ` `class` `GFG {``    ``// To do two way sort. First sort even numbers in``    ``// ascending order, then odd numbers in descending``    ``// order.``    ``static` `void` `twoWaySort(``int``[] arr, ``int` `n)``    ``{``        ``// Current indexes from left and right``        ``int` `l = 0, r = n - 1;`` ` `        ``// Count of odd numbers``        ``int` `k = 0;`` ` `        ``while` `(l < r) ``        ``{``         ` `            ``// Find first even number ``            ``// from left side.``            ``while` `(arr[l] % 2 != 0) ``            ``{``                ``l++;``                ``k++;``            ``}`` ` `            ``// Find first odd number from right side.``            ``while` `(arr[r] % 2 == 0 && l < r)``                ``r--;`` ` `            ``// Swap even number present ``            ``// on left and odd``            ``// number right.``            ``if` `(l < r) {``                ``// swap arr[l] arr[r]``                ``int` `temp = arr[l];``                ``arr[l] = arr[r];``                ``arr[r] = temp;``            ``}``        ``}`` ` `        ``// Sort odd number in descending order``        ``Array.Sort(arr, 0, k);``        ``Array.Reverse(arr, 0, k);`` ` `        ``// Sort even number in ascending order``        ``Array.Sort(arr, k, n - k);``    ``}`` ` `    ``// Driver Method``    ``public` `static` `void` `Main(String[] args)``    ``{``        ``int``[] arr = { 1, 3, 2, 7, 5, 4 };`` ` `        ``twoWaySort(arr, arr.Length);`` ` `        ``Console.WriteLine(String.Join(``" "``, arr));``    ``}``}`` ` `// This code has been contributed by 29AjayKumar`

## Javascript

 ``

Output

```7 5 3 1 2 4

```

Time complexity: O(n log n)
Auxiliary Space: O(1)

Method 2 (Using negative multiplication) :

1. Make all odd numbers negative.
2. Sort all numbers.
3. Revert the changes made in step 1 to get original elements back.

Implementation:

## C++

 `// C++ program sort array in even and odd manner.``// The odd numbers are to be sorted in descending``// order and the even numbers in ascending order``#include ``using` `namespace` `std;`` ` `// To do two way sort. First sort even numbers in``// ascending order, then odd numbers in descending``// order.``void` `twoWaySort(``int` `arr[], ``int` `n)``{``    ``// Make all odd numbers negative``    ``for` `(``int` `i = 0; i < n; i++)``        ``if` `(arr[i] & 1) ``// Check for odd``            ``arr[i] *= -1;`` ` `    ``// Sort all numbers``    ``sort(arr, arr + n);`` ` `    ``// Retaining original array``    ``for` `(``int` `i = 0; i < n; i++)``        ``if` `(arr[i] & 1)``            ``arr[i] *= -1;``}`` ` `// Driver code``int` `main()``{``    ``int` `arr[] = { 1, 3, 2, 7, 5, 4 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(``int``);``    ``twoWaySort(arr, n);``    ``for` `(``int` `i = 0; i < n; i++)``        ``cout << arr[i] << ``" "``;``    ``return` `0;``}`

## Java

 `// Java program sort array in even and odd manner.``// The odd numbers are to be sorted in descending``// order and the even numbers in ascending order`` ` `import` `java.util.Arrays;`` ` `public` `class` `GFG ``{``    ``// To do two way sort. First sort even numbers in``    ``// ascending order, then odd numbers in descending``    ``// order.``    ``static` `void` `twoWaySort(``int` `arr[], ``int` `n)``    ``{``        ``// Make all odd numbers negative``        ``for` `(``int` `i = ``0``; i < n; i++)``            ``if` `((arr[i] & ``1``) != ``0``) ``// Check for odd``                ``arr[i] *= -``1``;`` ` `        ``// Sort all numbers``        ``Arrays.sort(arr);`` ` `        ``// Retaining original array``        ``for` `(``int` `i = ``0``; i < n; i++)``            ``if` `((arr[i] & ``1``) != ``0``)``                ``arr[i] *= -``1``;``    ``}`` ` `    ``// Driver Method``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `arr[] = { ``1``, ``3``, ``2``, ``7``, ``5``, ``4` `};`` ` `        ``twoWaySort(arr, arr.length);`` ` `        ``System.out.println(Arrays.toString(arr));``    ``}``}`

## Python3

 `# Python 3 program to sort array in ``# even and odd manner. The odd``# numkbers are to be sorted in ``# descending order and the even ``# numbers in ascending order`` ` `# To do two way sort. First sort ``# even numbers in ascending order,``# then odd numbers in descending order.``def` `twoWaySort(arr, n):`` ` `    ``# Make all odd numbers negative``    ``for` `i ``in` `range``(``0``, n):``         ` `        ``# Check for odd``        ``if` `(arr[i] & ``1``): ``            ``arr[i] ``*``=` `-``1`` ` `    ``# Sort all numbers``    ``arr.sort()`` ` `    ``# Retaining original array``    ``for` `i ``in` `range``(``0``, n):``        ``if` `(arr[i] & ``1``):``            ``arr[i] ``*``=` `-``1`` ` `# Driver code``arr ``=` `[``1``, ``3``, ``2``, ``7``, ``5``, ``4``]``n ``=` `len``(arr)``twoWaySort(arr, n);``for` `i ``in` `range``(``0``, n):``    ``print``(arr[i], end ``=` `" "``)``     ` `# This code is contributed by Smitha Dinesh Semwal`

## C#

 `// Java program sort array in even and``// odd manner. The odd numbers are to``// be sorted in descending order and``// the even numbers in ascending order``using` `System;`` ` `public` `class` `GFG ``{`` ` `    ``// To do two way sort. First sort``    ``// even numbers in ascending order,``    ``// then odd numbers in descending``    ``// order.``    ``static` `void` `twoWaySort(``int``[] arr, ``int` `n)``    ``{`` ` `        ``// Make all odd numbers negative``        ``for` `(``int` `i = 0; i < n; i++)`` ` `            ``// Check for odd``            ``if` `((arr[i] & 1) != 0)``                ``arr[i] *= -1;`` ` `        ``// Sort all numbers``        ``Array.Sort(arr);`` ` `        ``// Retaining original array``        ``for` `(``int` `i = 0; i < n; i++)``            ``if` `((arr[i] & 1) != 0)``                ``arr[i] *= -1;``    ``}`` ` `    ``// Driver Method``    ``public` `static` `void` `Main()``    ``{``        ``int``[] arr = { 1, 3, 2, 7, 5, 4 };`` ` `        ``twoWaySort(arr, arr.Length);`` ` `        ``for` `(``int` `i = 0; i < arr.Length; i++)``            ``Console.Write(arr[i] + ``" "``);``    ``}``}`` ` `// This code is contributed by Smitha`

## Javascript

 ``

## PHP

 ``

Output

```7 5 3 1 2 4

```

Time complexity: O(n log n)
Auxiliary Space: O(1)

This method may not work when input array contains negative numbers. However, there is a way to handle this. We count the positive odd integers in the input array then sort again. Readers may refer this for implementation.

Method 3 (Using comparator):
This problem can be easily solved by using the inbuilt sort function with a custom compare method. On comparing any two elements there will be three cases:

1. When both the elements are even: In this case, the smaller element must appear in the left of the larger element in the sorted array.
2. When both the elements are odd: The larger element must appear on left of the smaller element.
3. One is odd and the other is even: The element which is odd must appear on the left of the even element.

Below is the implementation of the above approach:

## CPP

 `// C++ implementation of the approach``#include ``using` `namespace` `std;`` ` `// Utility function to print``// the contents of the array``void` `printArr(``int` `arr[], ``int` `n)``{``    ``for` `(``int` `i = 0; i < n; i++)``        ``cout << arr[i] << ``" "``;``}`` ` `// To do two way sort. Make comparator function``// for the inbuilt sort function of c++ such that``// odd numbers are placed before even in descending``// and ascending order respectively``bool` `compare(``int` `a, ``int` `b)``{``     ` `    ``// If both numbers are even, ``    ``// smaller number should``    ``// be placed at lower index``    ``if` `(a % 2 == 0 && b % 2 == 0)``        ``return` `a < b;`` ` `    ``// If both numbers are odd larger number``    ``// should be placed at lower index``    ``if` `(a % 2 != 0 && b % 2 != 0)``        ``return` `b < a;`` ` `    ``// If a is odd and b is even, ``    ``// a should be placed before b``    ``if` `(a % 2 != 0)``        ``return` `true``;`` ` `    ``// If b is odd and a is even, ``    ``// b should be placed before a``    ``return` `false``;``}`` ` `// Driver code``int` `main()``{``    ``int` `arr[] = { 1, 3, 2, 7, 5, 4 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(``int``);`` ` `    ``// Sort the array``    ``sort(arr, arr + n, compare);`` ` `    ``// Print the sorted array``    ``printArr(arr, n);`` ` `    ``return` `0;``}`` ` `// This code is contributed by Nikhil Yadav`

## Java

 `// Java implementation of the approach``import` `java.util.ArrayList;``import` `java.util.Collections;``import` `java.util.Comparator;`` ` `class` `GFG``{`` ` `    ``// Utility function to print``    ``// the contents of the array``    ``static` `void` `printArr(ArrayList arr, ``int` `n) {``        ``for` `(``int` `i = ``0``; i < n; i++)``            ``System.out.print(arr.get(i) + ``" "``);``    ``}`` ` `    ``// Driver code``    ``public` `static` `void` `main(String args[]) {``        ``ArrayList arr = ``new` `ArrayList();``        ``arr.add(``1``);``        ``arr.add(``3``);``        ``arr.add(``2``);``        ``arr.add(``7``);``        ``arr.add(``5``);``        ``arr.add(``4``);``        ``int` `n = arr.size();`` ` ` ` `        ``// Sort the array``        ``Collections.sort(arr, ``new` `Comparator() {``            ``@Override``            ``public` `int` `compare(Integer a, Integer b) {`` ` `                ``// If both numbers are even,``                ``// smaller number should``                ``// be placed at lower index``                ``if` `(a % ``2` `== ``0` `&& b % ``2` `== ``0``)``                    ``return` `(a - b);`` ` `                ``// If both numbers are odd larger number``                ``// should be placed at lower index``                ``if` `(a % ``2` `!= ``0` `&& b % ``2` `!= ``0``)``                    ``return` `(b - a);`` ` `                ``// If a is odd and b is even,``                ``// a should be placed before b``                ``if` `(a % ``2` `!= ``0``)``                    ``return` `-``1``;`` ` `                ``// If b is odd and a is even,``                ``// b should be placed before a``                ``return` `0``;``            ``}``        ``});``         ` `        ``// Print the sorted array``        ``printArr(arr, n);``    ``}``}`` ` `// This code is contributed by Saurabh Jaiswal`

## Python3

 `# Python3 implementation of the approach`` ` `# Utility function to print``# the contents of the array``from` `functools ``import` `cmp_to_key`` ` `def` `printArr(arr, n):``             ` `    ``for` `i ``in` `range``(n):``        ``print``(arr[i], end ``=` `" "``)`` ` `        ``# To do two way sort. Make comparator function``        ``# for the inbuilt sort function of c++ such that``        ``# odd numbers are placed before even in descending``        ``# and ascending order respectively``def` `compare(a, b):`` ` `    ``# If both numbers are even, ``    ``# smaller number should``    ``# be placed at lower index``    ``if` `(a ``%` `2` `=``=` `0` `and` `b ``%` `2` `=``=` `0` `and` `a < b):``        ``return` `-``1`` ` `    ``# If both numbers are odd larger number``    ``# should be placed at lower index``    ``if` `(a ``%` `2` `!``=` `0` `and` `b ``%` `2` `!``=` `0` `and` `b > a):``        ``return` `1`` ` `    ``# If a is odd and b is even, ``    ``# a should be placed before b``    ``if` `(a ``%` `2` `!``=` `0``):``        ``return` `-``1`` ` `    ``# If b is odd and a is even, ``    ``# b should be placed before a``    ``return` `1`` ` `# Driver code``arr ``=` `[``1``, ``3``, ``2``, ``7``, ``5``, ``4``]``n ``=` `len``(arr)`` ` `# Sort the array``arr.sort(key ``=` `cmp_to_key(compare))`` ` `# Print the sorted array``printArr(arr, n)``         ` `# This code is contributed by shinjanpatra`

## C#

 `// C# implementation of the approach``using` `System;``using` `System.Collections.Generic;`` ` `public` `class` `GFG``{`` ` `  ``// Utility function to print``  ``// the contents of the array``  ``static` `void` `printArr(List<``int``> arr, ``int` `n) {``    ``for` `(``int` `i = 0; i < n; i++)``      ``Console.Write(arr[i] + ``" "``);``  ``}``  ``private` `static` `int` `Compare(``int` `a, ``int` `b)``  ``{`` ` `    ``// If both numbers are even,``    ``// smaller number should``    ``// be placed at lower index``    ``if` `(a % 2 == 0 && b % 2 == 0 && aa)``      ``return` `1;`` ` `    ``// If a is odd and b is even,``    ``// a should be placed before b``    ``if` `(a % 2 != 0)``      ``return` `-1;`` ` `    ``// If b is odd and a is even,``    ``// b should be placed before a``    ``return` `1;``  ``}`` ` `  ``// Driver code``  ``public` `static` `void` `Main(String []args) {``    ``List<``int``> arr = ``new` `List<``int``>();``    ``arr.Add(1);``    ``arr.Add(3);``    ``arr.Add(2);``    ``arr.Add(7);``    ``arr.Add(5);``    ``arr.Add(4);``    ``int` `n = arr.Count;`` ` `    ``// Sort the array``    ``arr.Sort(Compare);`` ` `    ``// Print the sorted array``    ``printArr(arr, n);``  ``}``}`` ` ` ` `// This code is contributed by 29AjayKumar`

## Javascript

 ``

Output

```7 5 3 1 2 4

```

Time complexity : O(n*logn) [sort function has average time complexity n*logn]
Auxiliary Space : O(1)

Thanks to Amandeep Singh for suggesting this solution.

This article is contributed by DANISH_RAZA. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.