# Rearrange array such that difference of adjacent elements is in descending order

Given an array a[] with n integers the task is to rearrange the elements of the array in such a way that the differences of the adjacent elements are in descending order.

Examples:

```Input : arr[] = {1, 2, 3, 4, 5, 6}
Output : 6 1 5 2 4 3
Explanation:
For first two elements the difference is abs(6-1)=5
For next two elements the difference is abs(1-5)=4
For next two elements the difference is abs(5-2)=3
For next two elements the difference is abs(2-4)=2
For next two elements the difference is abs(4-3)=1
Hence, difference array is 5, 4, 3, 2, 1.

Input : arr[] = {7, 10, 2, 4, 5}
Output : 10 2 7 4 5
Explanation:
For first two elements the difference is abs(10-2)=8
For next two elements the difference is abs(2-7)=5
For next two elements the difference is abs(7-4)=3
For next two elements the difference is abs(4-5)=1
Hence, difference array is 8, 5, 3, 1.
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach:

To solve the problem mentioned above we have to sort the array and then print the elements in the following order for the even-sized array :

a[n], a[1], a[n-1], a[2] ….. a[(n/2)], [(n/2)+1]

And for odd-sized array, we have to print array elements in the following order:

a[n], a[1], a[n-1], a[2] ….. a[(n/2)+1]

Below is the implementation of the above approach:

## C++

 `// C++ implementation to Rearrange array ` `// such that difference of adjacent ` `// elements is in descending order ` ` `  `#include ` `using` `namespace` `std; ` ` `  `// Function to print array in given order ` `void` `printArray(``int``* a, ``int` `n) ` `{ ` `    ``// Sort the array ` `    ``sort(a, a + n); ` `    ``int` `i = 0; ` `    ``int` `j = n - 1; ` ` `  `    ``// Check elements till the middle index ` `    ``while` `(i <= j) { ` `        ``// check if length is odd ` `        ``// print the middle index at last ` `        ``if` `(i == j) { ` `            ``cout << a[i] << ``" "``; ` `        ``} ` `        ``// Print the remaining elements ` `        ``// in the described order ` `        ``else` `{ ` `            ``cout << a[j] << ``" "``; ` `            ``cout << a[i] << ``" "``; ` `        ``} ` `        ``i = i + 1; ` `        ``j = j - 1; ` `    ``} ` `    ``cout << endl; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` ` `  `    ``// array declaration ` `    ``int` `arr1[] = { 1, 2, 3, 4, 5, 6 }; ` ` `  `    ``// size of array ` `    ``int` `n1 = ``sizeof``(arr1) / ``sizeof``(arr1[0]); ` ` `  `    ``printArray(arr1, n1); ` `} `

## Java

 `// Java implementation to Rearrange array ` `// such that difference of adjacent ` `// elements is in descending order ` `import` `java.util.*; ` ` `  `class` `GFG { ` `     `  `// Function to print array in given order ` `static` `void` `printArray(``int` `[]a, ``int` `n) ` `{ ` `     `  `    ``// Sort the array ` `    ``Arrays.sort(a); ` `     `  `    ``int` `i = ``0``; ` `    ``int` `j = n - ``1``; ` `     `  `    ``// Check elements till the  ` `    ``// middle index ` `    ``while` `(i <= j) ` `    ``{ ` `         `  `        ``// Check if length is odd print ` `        ``// the middle index at last ` `        ``if` `(i == j) ` `        ``{ ` `            ``System.out.print(a[i] + ``" "``); ` `        ``} ` `         `  `        ``// Print the remaining elements ` `        ``// in the described order ` `        ``else`  `        ``{ ` `            ``System.out.print(a[j] + ``" "``); ` `            ``System.out.print(a[i] + ``" "``); ` `        ``} ` `        ``i = i + ``1``; ` `        ``j = j - ``1``; ` `    ``} ` `    ``System.out.println(); ` `} ` `     `  `// Driver code ` `public` `static` `void` `main (String[] args)  ` `{ ` `     `  `    ``// Array declaration ` `    ``int` `arr1[] = { ``1``, ``2``, ``3``, ``4``, ``5``, ``6` `}; ` `     `  `    ``// Size of array ` `    ``int` `n1 = arr1.length; ` `     `  `    ``printArray(arr1, n1); ` `}     ` `} ` ` `  `// This code is contributed by AnkitRai01 `

## Python3

 `# Python3 implementation to rearrange   ` `# array such that difference of adjacent  ` `# elements is in descending order  ` ` `  `# Function to print array in given order  ` `def` `printArray(a, n):  ` `     `  `    ``# Sort the array  ` `    ``a.sort(); ` `     `  `    ``i ``=` `0``;  ` `    ``j ``=` `n ``-` `1``;  ` ` `  `    ``# Check elements till the middle index  ` `    ``while` `(i <``=` `j): ` `         `  `        ``# Check if length is odd print ` `        ``# the middle index at last  ` `        ``if` `(i ``=``=` `j): ` `            ``print``(a[i], end ``=` `" "``);  ` `             `  `        ``# Print the remaining elements  ` `        ``# in the described order  ` `        ``else` `: ` `            ``print``(a[j], end ``=` `" "``); ` `            ``print``(a[i], end ``=` `" "``);  ` `         `  `        ``i ``=` `i ``+` `1``;  ` `        ``j ``=` `j ``-` `1``;  ` ` `  `    ``print``(); ` ` `  `# Driver code  ` `if` `__name__ ``=``=` `"__main__"` `:  ` ` `  `    ``# Array declaration  ` `    ``arr1 ``=` `[ ``1``, ``2``, ``3``, ``4``, ``5``, ``6` `];  ` ` `  `    ``# Size of array  ` `    ``n1 ``=` `len``(arr1);  ` ` `  `    ``printArray(arr1, n1);  ` ` `  `# This code is contributed by AnkitRai01 `

## C#

 `// C# implementation to rearrange array ` `// such that difference of adjacent ` `// elements is in descending order ` `using` `System; ` ` `  `class` `GFG { ` `         `  `// Function to print array in given order ` `static` `void` `printArray(``int` `[]a, ``int` `n) ` `{ ` `         `  `    ``// Sort the array ` `    ``Array.Sort(a); ` `         `  `    ``int` `i = 0; ` `    ``int` `j = n - 1; ` `         `  `    ``// Check elements till the  ` `    ``// middle index ` `    ``while` `(i <= j) ` `    ``{ ` `             `  `        ``// Check if length is odd print ` `        ``// the middle index at last ` `        ``if` `(i == j) ` `        ``{ ` `            ``Console.Write(a[i] + ``" "``); ` `        ``} ` `             `  `        ``// Print the remaining elements ` `        ``// in the described order ` `        ``else` `        ``{ ` `            ``Console.Write(a[j] + ``" "``); ` `            ``Console.Write(a[i] + ``" "``); ` `        ``} ` `        ``i = i + 1; ` `        ``j = j - 1; ` `    ``} ` `    ``Console.WriteLine(); ` `} ` `         `  `// Driver code ` `public` `static` `void` `Main (``string``[] args)  ` `{ ` `         `  `    ``// Array declaration ` `    ``int` `[]arr1 = { 1, 2, 3, 4, 5, 6 }; ` `         `  `    ``// Size of array ` `    ``int` `n1 = arr1.Length; ` `         `  `    ``printArray(arr1, n1); ` `}      ` `} ` ` `  `// This code is contributed by AnkitRai01`

Output:

```6 1 5 2 4 3
```

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.

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.

Improved By : AnkitRai01