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++ 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 <bits/stdc++.h> 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<n;i++){
//If number is even push them to even vector
if (arr[i]%2==0){even.push_back(arr[i]);}
//If number is odd push them to odd vector
else {odd.push_back(arr[i]);}
}
//Sort even array in ascending order
sort(even.begin(),even.end());
//Sort odd array in descending order
sort(odd.begin(),odd.end(),greater< int >());
int i=0;
//First store odd numbers to array
for ( int j=0;j<odd.size();j++){
arr[i]=odd[j];
i++;
}
//Then store even numbers to array
for ( int j=0;j<even.size();j++){
arr[i]=even[j];
i++;
}
} // 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 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<Integer> odd = new ArrayList<>();
// To store Even Numbers
List<Integer> 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] + " " );
}
}
} |
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# 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 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 |
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)
- 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).
- 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++ 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 <bits/stdc++.h> 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 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 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# 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 |
<script> // 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 // To do two way sort.
// First sort even numbers in
// ascending order, then odd
// numbers in descending
// order.
function twoWaySort(arr,n)
{
// Current indexes from
// left and right
let l = 0, r = n - 1;
// Count of odd numbers
let 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]
let temp = arr[l];
arr[l] = arr[r];
arr[r] = temp;
}
}
let odd= new Array(k);
for (let i=0;i<k;i++)
{
odd[i]=arr[i];
}
let even= new Array(n-k);
for (let i=0;i<n-k;i++)
{
even[i]=arr[k+i];
}
// Sort odd number in descending order
odd.sort( function (a,b){ return b-a;});
// Sort even number in ascending order
even.sort( function (a,b){ return a-b;});
return odd.concat(even);
}
// Driver Method
let arr=[1, 3, 2, 7, 5, 4 ];
let ans=twoWaySort(arr, arr.length);
for (let i=0;i<ans.length;i++)
{
document.write(ans[i]+ " " );
}
// This code is contributed by rag2127
</script> |
7 5 3 1 2 4
Time complexity: O(n log n)
Auxiliary Space: O(1)
Method 2 (Using negative multiplication) :
- Make all odd numbers negative.
- Sort all numbers.
- Revert the changes made in step 1 to get original elements back.
Implementation:
// 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 <bits/stdc++.h> 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 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));
}
} |
# 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 |
// 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 |
<script> // 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 // To do two way sort. First sort even numbers in // ascending order, then odd numbers in descending // order. function twoWaySort(arr, n)
{ // Make all odd numbers negative
for (let i = 0; i < n; i++)
if (arr[i] & 1) // Check for odd
arr[i] *= -1;
// Sort all numbers
arr.sort((a,b) => a-b);
// Retaining original array
for (let i = 0; i < n; i++)
if (arr[i] & 1)
arr[i] *= -1;
} // Driver code let arr = [ 1, 3, 2, 7, 5, 4 ];
let n = arr.length;
twoWaySort(arr, n);
for (let i = 0; i < n; i++)
document.write(arr[i] + " " );
//This code is contributed by Mayank Tyagi </script> |
<?php // PHP 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 // To do two way sort. First sort even numbers in // ascending order, then odd numbers in descending // order. function twoWaySort(& $arr , $n )
{ // Make all odd numbers negative
for ( $i = 0 ; $i < $n ; $i ++)
if ( $arr [ $i ] & 1) // Check for odd
$arr [ $i ] *= -1;
// Sort all numbers
sort( $arr );
// Retaining original array
for ( $i = 0 ; $i < $n ; $i ++)
if ( $arr [ $i ] & 1)
$arr [ $i ] *= -1;
} // Driver code $arr = array (1, 3, 2, 7, 5, 4);
$n = sizeof( $arr );
twoWaySort( $arr , $n );
for ( $i = 0; $i < $n ; $i ++)
echo $arr [ $i ] . " " ;
// This code is contributed by ita_c ?> |
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:
- 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.
- When both the elements are odd: The larger element must appear on left of the smaller element.
- 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:
// C++ implementation of the approach #include <bits/stdc++.h> 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 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<Integer> 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<Integer> arr = new ArrayList<Integer>();
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<Integer>() {
@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 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# 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 && a<b)
return -1;
// If both numbers are odd larger number
// should be placed at lower index
if (a % 2 != 0 && b % 2 != 0 && 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
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 |
<script> // JavaScript implementation of the approach
// Utility function to print
// the contents of the array
function printArr(arr, n)
{
for (let i = 0; i < n; i++)
document.write(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
function compare(a, b) {
// If both numbers are even,
// smaller number should
// be placed at lower index
if (a % 2 == 0 && b % 2 == 0 && a < b)
return -1;
// If both numbers are odd larger number
// should be placed at lower index
if (a % 2 != 0 && b % 2 != 0 && 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
var arr = [1, 3, 2, 7, 5, 4];
var n = arr.length;
// Sort the array
arr.sort(compare);
// Print the sorted array
printArr(arr, n);
// This code is contributed by Potta Lokesh </script>
|
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.