Skip to content
Related Articles

Related Articles

Minimize the maximum absolute difference of adjacent elements in a circular array
  • Difficulty Level : Medium
  • Last Updated : 09 Nov, 2020

Given a circular array arr of N integers, the task is to minimize the maximum absolute difference of adjacent elements of the array without any removals.

Examples: 

Input: arr[] = {1, 3, 10, 2, 0, 9, 6} 
Output: {0, 2, 6, 10, 9, 3, 1} 
Explanation: In the above example, the maximum difference between adjacent elements is 6, which is between 9 and 3. Other orderings won’t be able to further minimize it.

Input: arr[] = {1, 2, 3, 4, 5, 6} 
Output: {1, 3, 5, 6, 4, 2} 
Example: The maximum difference is 2 between (1, 3) and (3, 5) and (6, 4) and (4, 2). 
 

Approach
In order to solve the problem, just displaying the sorted array would lead to an incorrect solution as it is treated as a circular array. After sorting, the last and first indexed elements are the highest and lowest elements in the array respectively. Thus, the maximum difference between adjacent elements can be further minimized. So, after sorting, we need to reorder the sorted array such that the even indexed elements precede the odd indexed elements of the array and arrange the odd indexed elements in reverse order.



Illustration: For the given array arr[] = {1, 3, 10, 2, 0, 9, 6}, the sorted array will be {0, 1, 2, 3, 6, 9, 10}. The maximum difference between adjacent elements in the cirular array is |10 – 0| = 10. After reordering the array based on the above approach, we get the array to be {0, 2, 6, 10, 9, 3, 1}. Thus, the maximum difference is now minimized to |9 – 3| = 6
 

Below code is the implementation of the above approach: 

C++




// C++ Program to minimize the
// maximum absolute difference
// between adjacent elements
// of the circular array
 
#include <bits/stdc++.h>
using namespace std;
 
#define ll long long
 
// Function to print the reordered array
// which minimizes thee maximum absolute
// difference of adjacent elements
void solve(vector<int>& arr, int N)
{
    // Sort the given array
    sort(arr.begin(), arr.end());
    // Reorder the array
    int fl = 1,k=0;
    for(int i=0;i<=N/2;i++)
    {
        if((i%2 && fl) || !fl)
        {
            int x = arr[i];
            arr.erase(arr.begin() + i);
            arr.insert(arr.begin() + N - 1 - k, x);
            k++;
            fl = 0;
        }
    }
    // Print the new ordering
    for (int i : arr)
        cout << i << " ";
}
 
 
// Driver code
int main()
{
    int N = 7;
    vector<int> arr = {1, 3, 10, 2, 0, 9, 6};
    solve(arr, N);
     
    return 0;
}
 
// this code is contributed by divyanshu gupta

Java




// Java program to minimize the
// maximum absolute difference
// between adjacent elements
// of the circular array
import java.util.*;
 
class GFG{
 
// Function to print the reordered array
// which minimizes thee maximum absolute
// difference of adjacent elements
static void solve(Vector<Integer> arr, int N)
{
     
    // Sort the given array
    Collections.sort(arr);
     
    // Reorder the array
    int fl = 1, k = 0;
     
    for(int i = 0; i <= N / 2; i++)
    {
        if ((i % 2 != 0 && fl != 0) || fl == 0)
        {
            int x = arr.get(i);
            arr.remove(i);
            arr.add( N - 1 - k, x);
            k++;
            fl = 0;
        }
    }
     
    // Print the new ordering
    for(int i : arr)
        System.out.print(i + " ");
}
 
// Driver code
public static void main(String[] args)
{
    int N = 7;
    Vector<Integer> arr = new Vector<>();
     
    arr.add(1);
    arr.add(3);
    arr.add(10);
    arr.add(2);
    arr.add(0);
    arr.add(9);
    arr.add(6);
     
    solve(arr, N);
}
}
 
// This code is contributed by Amit Katiyar

Python3




# Python3 Program to minimize the
# maximum absolute difference
# between adjacent elements
# of the circular array
 
# Function to print the reordered array
# which minimizes thee maximum absolute
# difference of adjacent elements
def solve(arr, N):
     
    # Sort the given array
    arr.sort(reverse = False)
     
    # Reorder the array
    fl = 1
    k=0
    for i in range(N // 2 + 1):
        if((i % 2 and fl) or fl == 0):
            x = arr[i]
            arr.remove(arr[i])
            arr.insert(N - 1 - k, x)
            k += 1
            fl = 0
             
    # Print the new ordering
    for i in arr:
        print(i, end = " ")
 
# Driver code
if __name__ == '__main__':
     
    N = 7
     
    arr = [ 1, 3, 10, 2, 0, 9, 6 ]
    solve(arr, N)
 
 
# This code is contributed by Samarth

C#




// C# program to minimize the
// maximum absolute difference
// between adjacent elements
// of the circular array
using System;
using System.Collections.Generic;
class GFG{
 
// Function to print the
// reordered array which
// minimizes thee maximum
// absolute difference of
// adjacent elements
static void solve(List<int> arr,
                  int N)
{   
  // Sort the given array
  arr.Sort();
 
  // Reorder the array
  int fl = 1, k = 0;
 
  for(int i = 0; i <= N / 2; i++)
  {
    if ((i % 2 != 0 &&
         fl != 0) || fl == 0)
    {
      int x = arr[i];
      arr.RemoveAt(i);
      arr.Insert(N - 1 - k, x);
      k++;
      fl = 0;
    }
  }
 
  // Print the new ordering
  foreach(int i in arr)
    Console.Write(i + " ");
}
 
// Driver code
public static void Main(String[] args)
{
  int N = 7;
  List<int> arr = new List<int>();
 
  arr.Add(1);
  arr.Add(3);
  arr.Add(10);
  arr.Add(2);
  arr.Add(0);
  arr.Add(9);
  arr.Add(6);
 
  solve(arr, N);
}
}
 
// This code is contributed by Rajput-Ji
Output: 
0 2 6 10 9 3 1






 

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.

My Personal Notes arrow_drop_up
Recommended Articles
Page :