Sort odds in descending order and then evens ascending

Given an array arr[] of positive integers. The task is to sort them so that the first part of the array contains odd numbers sorted in descending order, and the rest of the portion contains even numbers sorted in ascending order.

Examples:

Input: arr[] = [1, 2, 3, 5, 4, 7, 10]
Output: [7, 5, 3, 1, 2, 4, 10]
Explanation: 7, 5, 3, 1 are odds in descending order and 2, 4, 10 are evens in ascending order.

Input: arr[] = [0, 4, 5, 3, 7, 2, 1]
Output: [7, 5, 3, 1, 0, 2, 4]
Explanation: 7, 5, 3, 1 are odds in descending order and 0, 2, 4 are evens in ascending order.

Input: arr[] = [6, 9, 2, 8, 3, 7]
Output: [9, 7, 3, 2, 6, 8]
Explanation: 9, 7, 3 are odds in descending order and 2, 6, 8 are evens in ascending order.

[Naive Approach] Using Two Auxiliary Arrays - O(n*log(n)) Time and O(n) Space

The idea is to first separate all odd and even numbers into two different arrays. Then, we sort the odd numbers in descending order and the even numbers in ascending order. Finally, we reconstruct the original array by placing all sorted odd numbers first, followed by the sorted even numbers.

7 5 3 1 2 4 10 

[Expected Approach - 1] Using Partition Method - O(n*log(n)) Time and O(1) Space

The idea is to partition the array such that all odd numbers are placed before the even numbers. Once partitioned, we can independently sort the odd and even parts: odds in descending and evens in ascending order. This avoids using extra space and gives an efficient in-place solution.

Steps to implement the above idea:

• Declare an integer left = 0 to track the position for placing odd numbers during partition.
• Traverse the array and swap current element with arr[left] if it is an odd number.
• Increment left after every successful odd placement to maintain correct boundary between odds and evens.
• After traversal, the array is partitioned with all odds on the left and evens on the right.
• Apply descending sort on the subarray from index 0 to left - 1 for odd numbers.
• Apply ascending sort on the subarray from index left to n - 1 for the even numbers.
• Finally, return the array.

7 5 3 1 2 4 10 

[Expected Approach - 2] Using Negative Multiplication - O(n*log(n)) Time and O(1) Space

The idea is to utilize the fact that negative odd numbers will be treated as smaller in ascending sort. So, we convert all odd elements to negative, making larger odd values more negative (e.g., 7 becomes -7). During sorting, these more negative values (i.e., originally bigger odds) are pushed further to the left, achieving descending order for odds. After sorting, we revert negative numbers back to positive, placing odds in descending order followed by evens in ascending order.

Note: This approach fails when the array already contains negative values, as it cannot distinguish between original and transformed negatives, leading to incorrect results.

7 5 3 1 2 4 10 

[Expected Approach - 3] Using Custom Comparator - O(n*log(n)) Time and O(1) Space

The idea is to leverage the inbuilt sort function with a custom comparator to sort the array according to the desired condition. The logic for the comparator is based on how two elements compare under three distinct cases:

• If both elements are even, they should be arranged in ascending order, so the smaller even number comes first.
• If both elements are odd, they should be arranged in descending order, meaning the larger odd number should appear earlier.
• If one element is odd and the other is even, the odd number must come before the even number to maintain the required order.

7 5 3 1 2 4 10