# 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++

 `// C++ program to sort an array based on absolute ` `// difference with a given value x. ` `#include ` `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); ` `    ``int` `x = 7; ` ` `  `    ``arrange(arr, n, x); ` `    ``print(arr, n); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java program to sort an array based on absolute ` `// difference with a given value x. ` `class` `GFG { ` ` `  `static` `void` `arrange(``int` `arr[], ``int` `n, ``int` `x) ` `{ ` `    ``// Below lines are similar to insertion sort ` `    ``for` `(``int` `i = ``1``; i < n; i++) { ` `        ``int` `diff = Math.abs(arr[i] - x); ` ` `  `        ``// Insert arr[i] at correct place ` `        ``int` `j = i - ``1``; ` `        ``if` `(Math.abs(arr[j] - x) > diff) ` `        ``{ ` `            ``int` `temp = arr[i]; ` `            ``while` `(j >= ``0` `&& Math.abs(arr[j] - x) > diff)  ` `            ``{ ` `                ``arr[j + ``1``] = arr[j]; ` `                ``j--; ` `            ``} ` `            ``arr[j + ``1``] = temp; ` `        ``} ` `    ``} ` `} ` ` `  `// Function to print the array ` `static` `void` `print(``int` `arr[], ``int` `n) ` `{ ` `    ``for` `(``int` `i = ``0``; i < n; i++) ` `    ``System.out.print(arr[i] + ``" "``); ` `} ` ` `  `// Driver code ` `public` `static` `void` `main(String[] args) { ` `    ``int` `arr[] = { ``10``, ``5``, ``3``, ``9``, ``2` `}; ` `    ``int` `n = arr.length; ` `    ``int` `x = ``7``; ` ` `  `    ``arrange(arr, n, x); ` `    ``print(arr, n); ` `    ``} ` `} ` ` `  `// This code is contributed by PrinciRaj1992 `

## Python 3

 `# Python 3 program to sort an array  ` `# based on absolute difference with ` `# a given value x. ` `def` `arrange(arr, n, x): ` ` `  `    ``# Below lines are similar to  ` `    ``# insertion sort ` `    ``for` `i ``in` `range``(``1``, n) : ` `        ``diff ``=` `abs``(arr[i] ``-` `x) ` ` `  `        ``# Insert arr[i] at correct place ` `        ``j ``=` `i ``-` `1` `        ``if` `(``abs``(arr[j] ``-` `x) > diff) : ` `            ``temp ``=` `arr[i] ` `            ``while` `(``abs``(arr[j] ``-` `x) >  ` `                       ``diff ``and` `j >``=` `0``) : ` `                ``arr[j ``+` `1``] ``=` `arr[j] ` `                ``j ``-``=` `1` `             `  `            ``arr[j ``+` `1``] ``=` `temp ` ` `  `# Function to print the array ` `def` `print_1(arr, n): ` ` `  `    ``for` `i ``in` `range``(n): ` `        ``print``(arr[i], end ``=` `" "``) ` ` `  `# Driver Code ` `if` `__name__ ``=``=` `"__main__"``: ` `     `  `    ``arr ``=` `[ ``10``, ``5``, ``3``, ``9``, ``2` `] ` `    ``n ``=` `len``(arr) ` `    ``x ``=` `7` ` `  `    ``arrange(arr, n, x) ` `    ``print_1(arr, n) ` ` `  `# This code is contributed by ita_c `

## C#

 `// C# program to sort an array based on absolute ` `// difference with a given value x. ` `using` `System; ` ` `  `class` `GFG  ` `{ ` ` `  `    ``static` `void` `arrange(``int` `[]arr, ``int` `n, ``int` `x) ` `    ``{ ` `         `  `        ``// Below lines are similar to insertion sort ` `        ``for` `(``int` `i = 1; i < n; i++) ` `        ``{ ` `            ``int` `diff = Math.Abs(arr[i] - x); ` ` `  `            ``// Insert arr[i] at correct place ` `            ``int` `j = i - 1; ` `            ``if` `(Math.Abs(arr[j] - x) > diff) ` `            ``{ ` `                ``int` `temp = arr[i]; ` `                ``while` `(j >= 0 && Math.Abs(arr[j] - x) > diff)  ` `                ``{ ` `                    ``arr[j + 1] = arr[j]; ` `                    ``j--; ` `                ``} ` `                ``arr[j + 1] = temp; ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``// Function to print the array ` `    ``static` `void` `print(``int` `[]arr, ``int` `n) ` `    ``{ ` `        ``for` `(``int` `i = 0; i < n; i++) ` `            ``Console.Write(arr[i] + ``" "``); ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `Main()  ` `    ``{ ` `        ``int` `[]arr = { 10, 5, 3, 9, 2 }; ` `        ``int` `n = arr.Length; ` `        ``int` `x = 7; ` ` `  `        ``arrange(arr, n, x); ` `        ``print(arr, n); ` `    ``} ` `} ` ` `  `// This code is contributed by 29AjayKumar `

## PHP

 ` ``\$diff``) ` `        ``{ ` `            ``\$temp` `= ``\$arr``[``\$i``]; ` `            ``while` `(``abs``(``\$arr``[``\$j``] - ``\$x``) >  ` `                       ``\$diff` `&& ``\$j` `>= 0)  ` `            ``{ ` `                ``\$arr``[``\$j` `+ 1] = ``\$arr``[``\$j``]; ` `                ``\$j``--; ` `            ``} ` `            ``\$arr``[``\$j` `+ 1] = ``\$temp``; ` `        ``} ` `    ``} ` `    ``return` `\$arr``; ` `} ` ` `  `// Function to print the array ` `function` `print_arr(``\$arr``, ``\$n``) ` `{ ` `    ``for` `(``\$i` `= 0; ``\$i` `< ``\$n``; ``\$i``++) ` `        ``echo` `\$arr``[``\$i``] . ``" "``; ` `} ` ` `  `// Driver Code ` `\$arr` `= ``array``(10, 5, 3, 9, 2); ` `\$n` `= sizeof(``\$arr``); ` `\$x` `= 7; ` ` `  `\$arr1` `= arrange(``\$arr``, ``\$n``, ``\$x``); ` `print_arr(``\$arr1``, ``\$n``); ` ` `  `// This code is contributed  ` `// by Akanksha Rai ` `?> `

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.