# Rearrange array to maximize count of local minima

• Last Updated : 15 Jun, 2021

Given an array arr[] of size N, the task is to rearrange the array elements such that the count of local minima in the array is maximum.

Note: An element arr[x] is said to be a local minimum if it is less than or equal to both its adjacent elements. The first and last array elements can’t be considered as local minima.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Examples:

Input: arr[]= {1, 2, 3, 4, 5}
Output: 3 1 4 2 5
Explanation:
Rearranging array elements to {3, 1, 4, 2, 5}. The count of local minima in the array is 2, i.e. {arr, arr}, which is the maximum possible count of local minima that can be obtained from the array. Therefore, the required output is 3 1 4 2 5.

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

Approach: The idea is to use sorting algorithms and two pointer technique to solve this problem. Follow the steps below to solve this problem:

• Sort the array in ascending order.
• Initialize two variables, say left = 0 and right = N / 2 to store the index of the left and right pointers respectively.
• Traverse the array and in each traversal, first print the value of arr[right] and then print the value of arr[left] and increment the value of left and right by 1.

Below is the implementation for the above approach:

## C++

 `// C++ program to implement``// the above approach``#include ``using` `namespace` `std;` `// Function to rearrange array elements to``// maximize count of local minima in the array``void` `rearrangeArrMaxcntMinima(``int` `arr[], ``int` `N)``{``    ``// Sort the array in``    ``// ascending order``    ``sort(arr, arr + N);` `    ``// Stores index of``    ``// left pointer``    ``int` `left = 0;` `    ``// Stores index of``    ``// right pointer``    ``int` `right = N / 2;` `    ``// Traverse the array elements``    ``while` `(left < N / 2 || right < N) {` `        ``// if right is less than N``        ``if` `(right < N) {` `            ``// Print array element``            ``cout << arr[right] << ``" "``;` `            ``// Update right``            ``right++;``        ``}` `        ``if` `(left < N / 2) {` `            ``// Print array element``            ``cout << arr[left] << ``" "``;` `            ``// Update left``            ``left++;``        ``}``    ``}``}` `// Driver Code``int` `main()``{` `    ``int` `arr[] = { 1, 2, 3, 4, 5 };` `    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);` `    ``rearrangeArrMaxcntMinima(arr, N);` `    ``return` `0;``}`

## Java

 `// Java program to implement``// the above approach``import` `java.util.*;` `class` `GFG{`` ` `// Function to rearrange array elements to``// maximize count of local minima in the array``static` `void` `rearrangeArrMaxcntMinima(``int` `arr[],``                                     ``int` `N)``{``    ` `    ``// Sort the array in``    ``// ascending order``    ``Arrays.sort(arr);`` ` `    ``// Stores index of``    ``// left pointer``    ``int` `left = ``0``;`` ` `    ``// Stores index of``    ``// right pointer``    ``int` `right = N / ``2``;`` ` `    ``// Traverse the array elements``    ``while` `(left < N / ``2` `|| right < N)``    ``{``        ` `        ``// If right is less than N``        ``if` `(right < N)``        ``{``            ` `            ``// Print array element``            ``System.out.print(arr[right] + ``" "``);`` ` `            ``// Update right``            ``right++;``        ``}`` ` `        ``if` `(left < N / ``2``)``        ``{``            ` `            ``// Print array element``            ``System.out.print(arr[left] + ``" "``);`` ` `            ``// Update left``            ``left++;``        ``}``    ``}``}`` ` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``int` `arr[] = { ``1``, ``2``, ``3``, ``4``, ``5` `};`` ` `    ``int` `N = arr.length;`` ` `    ``rearrangeArrMaxcntMinima(arr, N);``}``}` `// This code is contributed by code_hunt`

## Python3

 `# Python3 program to implement``# the above approach` `# Function to rearrange array``# elements to maximize count of``# local minima in the array``def` `rearrangeArrMaxcntMinima(arr, N):` `    ``# Sort the array in``    ``# ascending order``    ``arr.sort()` `    ``# Stores index of``    ``# left pointer``    ``left ``=` `0` `    ``# Stores index of``    ``# right pointer``    ``right ``=` `N ``/``/` `2` `    ``# Traverse the array elements``    ``while` `(left < N ``/``/` `2` `or``           ``right < N):` `        ``# if right is less``        ``# than N``        ``if` `(right < N):` `            ``# Print array element``            ``print``(arr[right],``                  ``end ``=` `" "``)` `            ``# Update right``            ``right ``+``=` `1` `        ``if` `(left < N ``/``/` `2``):` `            ``# Print array element``            ``print``(arr[left],``                  ``end ``=` `" "``)` `            ``# Update left``            ``left ``+``=` `1` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:``  ` `    ``arr ``=` `[``1``, ``2``, ``3``, ``4``, ``5``]``    ``N ``=` `len``(arr)``    ``rearrangeArrMaxcntMinima(arr, N)` `# This code is contributed by Chitranayal`

## C#

 `// C# program to implement``// the above approach``using` `System;` `class` `GFG{`` ` `// Function to rearrange array elements to``// maximize count of local minima in the array``static` `void` `rearrangeArrMaxcntMinima(``int` `[]arr,``                                     ``int` `N)``{``  ` `    ``// Sort the array in``    ``// ascending order``    ``Array.Sort(arr);`` ` `    ``// Stores index of``    ``// left pointer``    ``int` `left = 0;`` ` `    ``// Stores index of``    ``// right pointer``    ``int` `right = N / 2;`` ` `    ``// Traverse the array elements``    ``while` `(left < N / 2 || right < N)``    ``{``      ` `        ``// If right is less than N``        ``if` `(right < N)``        ``{``            ` `            ``// Print array element``            ``Console.Write(arr[right] + ``" "``);`` ` `            ``// Update right``            ``right++;``        ``}``        ``if` `(left < N / 2)``        ``{``            ` `            ``// Print array element``            ``Console.Write(arr[left] + ``" "``);`` ` `            ``// Update left``            ``left++;``        ``}``    ``}``}`` ` `// Driver Code``public` `static` `void` `Main(String[] args)``{``    ``int` `[]arr = { 1, 2, 3, 4, 5 };``    ``int` `N = arr.Length;`` ` `    ``rearrangeArrMaxcntMinima(arr, N);``}``}` `// This code is contributed by Rajput-Ji`

## Javascript

 ``
Output:
`3 1 4 2 5`

Time Complexity: O(N log(N))
Auxiliary Space:O(1)

My Personal Notes arrow_drop_up