Ordene una array según la diferencia absoluta con el valor dado usando Functors

Dada una array de n elementos distintos y un número x, ordene los elementos de la array de acuerdo con la diferencia absoluta con x, es decir, el elemento que tiene una diferencia mínima aparece primero y así sucesivamente.
Nota: si dos o más elementos están a la misma distancia, organícelos en la misma secuencia que en la array dada.

Ejemplos:

Entrada: x = 7, arr[] = {10, 5, 3, 9, 2}
Salida: arr[] = {5, 9, 10, 3, 2}
7 – 10 = 3(abs)
7 – 5 = 2
7 – 3 = 4
7 – 9 = 2(abs)
7 – 2 = 5
De acuerdo con la diferencia con x,
los elementos se organizan como 5, 9, 10, 3, 2.

Entrada: x = 6, arr[] = {1, 2, 3, 4, 5}
Salida: arr[] = {5, 4, 3, 2, 1}

Entrada: x = 5, arr[] = {2, 6, 8, 3}
Salida: arr[] = {6, 3, 2, 8}

Enfoque:
el problema anterior se ha explicado en la siguiente publicación:
Ordenar una array según la diferencia absoluta con un valor dado
Ordenar una array según la diferencia absoluta con un valor dado «usando espacio extra constante»

Las soluciones mencionadas anteriormente tienen una complejidad temporal de O(nlogn) con un espacio auxiliar de O(n) y O(n^2) con un espacio auxiliar de O(1) respectivamente. En este post se propone una solución con complejidad temporal de O(nlogn) usando un espacio auxiliar de O(1).

La solución se basa en Functors . Compara el valor absoluto de la diferencia del número dado, k con el valor de la array arr[i] y devuelve verdadero si el valor del primer objeto es menor que el segundo objeto. Se conserva el uso del orden de clasificación estable de valores equivalentes.

A continuación se muestra la implementación del enfoque anterior:

// C++ program to sort an array according
// absolute difference with x.
#include <bits/stdc++.h>
using namespace std;
  
// Functor class to perform comparison
class compare {
private:
    int num;
  
public:
    compare(int n)
    {
        num = n;
    }
  
    // Overloads () operator to perform
    // the desired comparison
    int operator()(int arr_num1, int arr_num2)
    {
        return abs(num - arr_num1) <
                          abs(num - arr_num2);
    }
};
  
// Function to sort an array according to
// absolute difference with x.
void rearrange(int arr[], int n, int k)
{
    // stable_sort sorts all the values in
    // non-decreasing order and preserves the
    // order of elements with equal values
    stable_sort(arr, arr + n, compare(k));
}
  
// Function to print the array
void printArray(int arr[], int n)
{
    for (int i = 0; i < n; i++)
        cout << arr[i] << " ";
}
  
// Driver code
int main()
{
    int arr[] = { 10, 5, 3, 9, 2 };
    int n = sizeof(arr) / sizeof(arr[0]);
    int k = 7;
  
    rearrange(arr, n, k);
  
    printArray(arr, n);
  
    return 0;
}

5 9 10 3 2

Complejidad de Tiempo : O(n Log n)
Espacio Auxiliar : O(1)