# Sort an array according to absolute difference with a given value “using constant extra space”

Given an array of n distinct elements and a number x, arrange array elements according to the absolute difference with x, i. e., element having minimum difference comes first and so on, using constant extra space.
Note : If two or more elements are at equal distance arrange them in same sequence as in the given array.

Examples:

```Input  : arr[] = {10, 5, 3, 9, 2}
x = 7
Output : arr[] = {5, 9, 10, 3, 2}
Explanation :
7 - 10 = 3(abs)
7 - 5 = 2
7 - 3 = 4
7 - 9 = 2(abs)
7 - 2 = 5
So according to the difference with X,
elements are arranged as 5, 9, 10, 3, 2.

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

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

The above problem has already been explained in a previous post here. It takes O(n log n) time and O(n) extra space. The below solution though has a relatively bad time complexity i.e O(n^2) but it does the work without using any additional space or memory.

The solution is a based on Insertion Sort . For every i (1<= i < n) we compare the absolute value of the difference of arr[i] with the given number x (Let this be 'diff' ). We then compare this difference with the difference of abs(arr[j]-x) where 0<= j < i (Let this if abdiff). If diff is greater than abdiff, we shift the values in the array to accommodate arr[i] in it's correct position.

```// C++ program to sort an array based on absolute
// difference with a given value x.
#include <bits/stdc++.h>
using namespace std;

void arrange(int arr[], int n, int x)
{
// Below lines are similar to insertion sort
for (int i = 1; i < n; i++) {
int diff = abs(arr[i] - x);

// Insert arr[i] at correct place
int j = i - 1;
if (abs(arr[j] - x) > diff) {
int temp = arr[i];
while (abs(arr[j] - x) > diff && j >= 0) {
arr[j + 1] = arr[j];
j--;
}
arr[j + 1] = temp;
}
}
}

// Function to print the array
void print(int arr[], int n)
{
for (int i = 0; i < n; i++)
cout << arr[i] << " ";
}

// Main Function
int main()
{
int arr[] = { 10, 5, 3, 9, 2 };
int n = sizeof(arr) / sizeof(arr[0]);
int x = 7;

arrange(arr, n, x);
print(arr, n);

return 0;
}
```

Output:

```5 9 10 3 2
```

Time Complexity : O(n^2) where n is the size of the array.
Auxiliary Space : O(1)

This article is contributed by Rohit Rao. 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.

# GATE CS Corner    Company Wise Coding Practice

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.
0 Average Difficulty : 0/5.0