Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

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[1], arr[3]}, 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 <bits/stdc++.h>
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[0]);
 
    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




<script>
 
// Javascript program to implement
// the above approach
 
// Function to rearrange array elements to
// maximize count of local minima in the array
function rearrangeArrMaxcntMinima(arr, N)
{
     
    // Sort the array in
    // ascending order
    arr.sort(function(a, b){return a - b;});
    
    // Stores index of
    // left pointer
    let left = 0;
   
    // Stores index of
    // right pointer
    let right = Math.floor(N / 2);
   
    // Traverse the array elements
    while (left < Math.floor(N / 2) || right < N)
    {
         
        // If right is less than N
        if (right < N)
        {
             
            // Print array element
            document.write(arr[right] + " ");
   
            // Update right
            right++;
        }
   
        if (left < Math.floor(N / 2))
        {
             
            // Print array element
            document.write(arr[left] + " ");
   
            // Update left
            left++;
        }
    }
}
 
// Driver Code
let arr = [ 1, 2, 3, 4, 5 ];
let N = arr.length;
 
rearrangeArrMaxcntMinima(arr, N);
 
// This code is contributed by avanitrachhadiya2155
 
</script>
Output: 
3 1 4 2 5

 

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




My Personal Notes arrow_drop_up
Recommended Articles
Page :