Skip to content
Related Articles

Related Articles

Sort first half in ascending and second half in descending order | Set 2
  • Difficulty Level : Basic
  • Last Updated : 13 Feb, 2020

Given an array of integers, sort the first half of the array in ascending order and second half in descending order.
Examples:

Input : arr[] = {10, 20, 30, 40}
Output : arr[] = {10, 20, 40, 30}

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

We have discussed a solution that only prints the required order in Sort first half in ascending and second half in descending order | Set 1

Simple Approach
The idea is simple, we sort the first half in increasing order and second half in decreasing using library function. Most of the languages like Java, C++ provide provision to sort a subarray in a specified order. In this post, a different solution is discussed that modifies the original array.

C++




// C++ program to sort first half in increasing
// order and second half in decreasing
#include<bits/stdc++.h>
using namespace std;
  
void mySort(int arr[], int n)
{
    sort(arr, arr+n/2);
    sort(arr+n/2, arr+n, greater<int>());
}
  
int main()
{
    int arr[] = { 5, 4, 6, 2, 1, 3, 8, 9, 7 };
    int n = sizeof(arr)/sizeof(arr[0]);
    mySort(arr, n);
    cout << "Modified Array : \n";
    for (int i=0; i<n; i++)
       cout << arr[i] << " ";
    return 0;
}


Java




// Java program to sort first half in increasing
// order and second half in decreasing
import java.util.*;
  
public class SortExample {
    static void mySort(Integer[] arr)
    {
        int n = arr.length;
  
        // Sort subarray from index 1 to 4, i.e.,
        // only sort subarray {7, 6, 45, 21} and
        // keep other elements as it is.
        Arrays.sort(arr, 0, n / 2);
        Arrays.sort(arr, n / 2, n, Collections.reverseOrder());
    }
  
    public static void main(String[] args)
    {
        // Our arr contains 8 elements
        Integer[] arr = { 5, 4, 6, 2, 1, 3, 8, 9, 7 };
        mySort(arr);
        System.out.printf("Modified arr[] : %s",
                          Arrays.toString(arr));
    }
}


Python 3




# Python3 program to sort first half in increasing
# order and second half in decreasing
  
# required sorting function
def mySort( arr, n):
      
    arr1 = arr[:n//2]
    arr2 = arr[n//2:]
    arr1.sort()
    arr2.sort(reverse=True)
    return arr1+arr2
      
      
  
# driving function
if __name__=='__main__':
    arr= [5, 4, 6, 2, 1, 3, 8, 9, 7 ]
    n = len(arr)
    arr=mySort(arr, n)
    print( "Modified Array : ")
    print(arr)
  
# this code is contributed by ash264


C#




// C# program to sort first half in increasing
// order and second half in decreasing
using System;
  
public class SortExample 
{
    static void mySort(int[] arr)
    {
        int n = arr.Length;
  
        // Sort subarray from index 1 to 4, i.e.,
        // only sort subarray {7, 6, 45, 21} and
        // keep other elements as it is.
        Array.Sort(arr, 0, n / 2);
        Array.Sort(arr, n / 2, (n/2)+1);
        Array.Reverse(arr, n / 2, (n/2)+1);
    }
  
    // Driver code
    public static void Main(String[] args)
    {
        // Our arr contains 8 elements
        int[] arr = { 5, 4, 6, 2, 1, 3, 8, 9, 7 };
        mySort(arr);
        Console.Write("Modified arr[] : {0}",
                        String.Join(" ",arr));
    }
}
  
/* This code contributed by PrinciRaj1992 */


PHP




<?php 
// PHP program to sort first half in increasing
// order and second half in decreasing
  
function mySort(&$arr, $n)
{
    $array1 = array_slice($arr, 0, 
                    floor($n / 2));
    $array2 = array_slice($arr, $n / 2);
    sort($array1);
    rsort($array2);
    $arr = array_merge($array1, $array2);
}
  
// Driver Code
$arr = array(5, 4, 6, 2, 1, 3, 8, 9, 7);
$n = sizeof($arr);
mySort($arr, $n);
  
echo "Modified array :\n";
for($i = 0; $i < $n; $i++)
    echo $arr[$i] . " ";
  
// This code is contributed by ita_c
?>


Output:

Modified array :
2 4 5 6 9 8 7 3 1 

Alternate Solution
1) Sort the whole array in ascending order.
2) Reverse the second half after sorting.



C++




// C++ program to sort first half in increasing
// order and second half in decreasing
#include<bits/stdc++.h>
using namespace std;
  
void mySort(int arr[], int n)
{
    // Sort the first half
    sort(arr, arr+n/2);
    sort(arr+n/2, arr+n);
  
    reverse(arr+n/2, arr+n);
}
  
int main()
{
    int arr[] = { 5, 4, 6, 2, 1, 3, 8, 9, 7 };
    int n = sizeof(arr)/sizeof(arr[0]);
    mySort(arr, n);
    cout << "Modified Array : \n";
    for (int i=0; i<n; i++)
       cout << arr[i] << " ";
    return 0;
}


Java




// Java program to sort first half in increasing
// order and second half in decreasing
import java.util.*;
  
public class SortExample {
    static void mySort(Integer[] arr)
    {
        int n = arr.length;
          
        // Sort the whole array 
        Arrays.sort(arr, 0, n/2);
        Arrays.sort(arr, n/2, n);
  
        // Reverse the second half
        int low = n/2, high = n-1;
        while (low < high)
        {
            Integer temp = arr[low];
            arr[low] = arr[high];
            arr[high] = temp;
            low++; high--;
        }  
    }
  
    public static void main(String[] args)
    {
        // Our arr contains 8 elements
        Integer[] arr = { 5, 4, 6, 2, 1, 3, 8, 9, 7 };
        mySort(arr);
        System.out.printf("Modified arr[] : %s",
                          Arrays.toString(arr));
    }
}


Python3




# Python3 program to sort first half in increasing
# order and second half in decreasing
def mySort(arr):
    n = len(arr);
  
    # Sort the whole array
    arr1 = arr[:n // 2]
    arr2 = arr[n // 2:]
    arr1.sort()
    arr2.sort()
    arr = arr1 + arr2
  
    # Reverse the second half
    low = n // 2;
    high = n - 1;
    while (low < high):
        temp = arr[low];
        arr[low] = arr[high];
        arr[high] = temp;
        low += 1;
        high -= 1;
    return arr;
  
# Driver code
if __name__ == '__main__':
      
    # Our arr contains 8 elements
    arr = [5, 4, 6, 2, 1, 3, 8, 9, 7];
    arr = mySort(arr);
    print("Modified Array : ")
    print(arr)
  
# This code is contributed by 29AjayKumar


C#




// C# program to sort first half in increasing 
// order and second half in decreasing 
using System;
  
public class SortExample 
    static void mySort(int[] arr) 
    
        int n = arr.Length; 
          
        // Sort the whole array 
        Array.Sort(arr, 0, n/2); 
        Array.Sort(arr, n/2, n/2+1); 
  
        // Reverse the second half 
        int low = n/2, high = n-1; 
        while (low < high) 
        
            int temp = arr[low]; 
            arr[low] = arr[high]; 
            arr[high] = temp; 
            low++; high--; 
        
    
  
    // Driver code
    public static void Main(String[] args) 
    
        // Our arr contains 8 elements 
        int[] arr = { 5, 4, 6, 2, 1, 3, 8, 9, 7 }; 
        mySort(arr); 
        Console.WriteLine("Modified arr[] : {0}"
                        String.Join(", ",arr)); 
    
  
// This code has been contributed by 29AjayKumar


Output:

Modified arr[] : [2, 4, 5, 6, 9, 8, 7, 3, 1]

Time Complexity of both approaches is O(n Log n)

Attention reader! Don’t stop learning now. Get hold of all the important Java Foundation and Collections concepts with the Fundamentals of Java and Java Collections Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up
Recommended Articles
Page :