Sort first half in ascending and second half in descending order | Set 2

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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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));
    }
}

chevron_right


Python 3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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 */

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

<?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
?>

chevron_right


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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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));
    }
}

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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

chevron_right


Output:

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

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



My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

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.





Article Tags :
Practice Tags :


Be the First to upvote.


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.