momentan scheitere ich daran eine eigene Sortierfunktion für QPointF an std::sort() zu übergeben.
Ich würde gerne einen std::vector<QPointF> in links/rechts vom Median sortieren:

class YMedianComparator
{
  QPointF yMedian;

public:
  YMedianComparator(QPointF _yMedian)
    : yMedian(_yMedian)
  {
  }

  bool operator < (const QPointF point) const { return yMedian.y() < point.y(); }
};

Der Aufruf:

std::sort(left, right, YMedianComparator(median));

Führt zu:

/usr/include/c++/5.2.1/bits/predefined_ops.h:144: Fehler: type 'YMedianComparator' does not provide a call operator
        { return bool(_M_comp(*__it, __val)); }
                      ^~~~~~~

Any ideas?

siehe:
http://en.cppreference.com/w/cpp/algorithm/sort

Was heißt den links / rechts einsortiert? Die Elemente sind untereinander sortiert, aber nicht zu einem speziellen Wert (von außen).

Also wenn ich Dich richtig verstehe würde ich das eher so sehen:

std::vector< QPointF > points;
std::vector< QPointF > pointsLeftMedian;
std::vector< QPointF > pointsRightMedian;

for( const QPointF& p : points ) {
  if( p < median ) {
    pointsLeftMedian.push_back( p );
  } else {
    pointsRightMedian.push_back( p );
  }
}

bool operator()( const T& lhs, const T& rhs ) const;

Wenn ein Vergleichswert konstant ist kannst du ihn z.B. mit std::bind2nd an den zweiten Parameter binden:

struct mycmp : std::binary_function<QPointF,QPointF,bool>
{
   bool operator( const QPointF& lhs, const QPointF& rhs ) const
   {
      return lhs.y() < rhs.y();
   }
};

QPointF median;
sort( v.begin(), v.end(), bind2nd( mycmp(), median ) );

Mit C++11 und Lambdas geht das aber bestimmt schöner.

Edit:
std::partition eignet sich hier besser als std:.sort

Ich würde die Vergleichsfunktion gerne übergeben:

void partitionField(std::vector<T>* field, int leftIndex, int rightIndex,
                      std::function<int(QPointF)>& compare)
  {
    auto left = field->begin();
    std::advance(left, leftIndex);

    // Ende ist bei std::partition() explizit, deshalb + 1
    auto right = field->begin();
    std::advance(right, rightIndex + 1);

    std::partition(left, right, compare);
  }

void bla() {
    // ...
    const auto f = [median](const QPointF& point) {
      return point.y() < median.y();
    };

    partitionField(x, leftIndex, rightIndex, f);
}

Leider liefert das einen Fehler:

Fehler: non-const lvalue reference to type 'std::function<int (QPointF)>' cannot bind to a value of unrelated type 'const (lambda at ../ComputGeom3/avltree.h:171:24)'
        partitionField(x, leftIndex, rightIndex, f);
                                                 ^

template < typename Comparator >
  void partitionField(std::vector<T>* field, int leftIndex, int rightIndex,
                      int medianIndex,
                      Comparator comp)
  {
    auto left = field->begin();
    std::advance(left, leftIndex);

    // Ende ist bei std::partition() explizit, deshalb + 1
    auto right = field->begin();
    std::advance(right, rightIndex + 1);

    std::nth_element(left, medianIndex, right, comp);
  }

void bla() {
    // ...
    partitionField<LessYComparator>(x, leftIndex, medianIndex, rightIndex, LessYComparator());
}

Fehler: no matching function for call to 'nth_element'
    std::nth_element(left, medianIndex, right, comp);
    ^~~~~~~~~~~~~~~~

Jedenfalls danke! Scheint erst mal zu funktionieren!

Folgendes soll reicht werden:

- Sort all points both by x- and y-coordinates
    => Two sorted sequences X and Y.

- Subdivide Y at its median and take it as the root of the tree
    => Two sub-sequences Y1 and Y2

- Partition X into two sequences X1 and X2, such that X1 contains the
same points as Y1 and X2 the same points as Y2.

- Partition X1 and X2 recursively at the median and subdivide Y1 and Y2
accordingly as above, until these sequences contain only one point.
    - These points are the leafs of the tree.

Dabei soll das Partitionieren in O(n) geschehen.

void partitionField(std::vector<QPointF>* field,
                    const int leftIndex,
                    const int rightIndex,
                    const std::function<int(QPointF)>& medianCompare)
  {
    auto leftIt = field->begin() + leftIndex;

    // Ende ist bei std::partition() explizit, deshalb + 1
    auto rightIt = field->begin() + rightIndex + 1;

    std::stable_partition(leftIt, rightIt, medianCompare);
  }

Dummerweise funktioniert das mit folgender Sort-Funktion nicht:

const auto compare = [yMedian](const QPointF& point) {
    return point.y() < yMedian.y();
  };

Compilierfähiger Code ist hier zu finden:

https://ideone.com/MZoeBL

Habe extra die Qt-Klasse QPointF abgebildet, damit das dort läuft.

Jemand eine Idee?!

template < typename MedianSort, typename OrderComparator >
  void partitionField(std::vector<T>* field,
                      const int leftIndex,
                      const int medianIndex,
                      const int rightIndex,
                      MedianSort medianSort,
                      OrderComparator orderSort)
  {
    auto leftIt = field->begin() + leftIndex;

    auto medianIt = field->begin() + medianIndex;

    // Ende ist bei std::partition() explizit, deshalb + 1
    auto rightIt = field->begin() + rightIndex + 1;

    std::sort(leftIt, rightIt, medianSort);

    std::sort(leftIt,       medianIt, orderSort);
    std::sort(medianIt + 1, rightIt,  orderSort);
  }

Ich habe nun getrickst. Keine Ahnung, ob die Lösung gut ist.

Ich glaube nicht, dass dies den gewünschten Laufzeitanforderungen gerecht wird. Viel zu viel Sortiererei. Wenn du dich an die Vorgabe hältst, muss nur ein einziges Mal (beziehungsweise 2x, da für x und y) am Anfang sortiert werden.

Wenn man die Ordnung beibehalten möchte, muss man sortieren und sortieren ist mind. n * log(n). Ich kann daher nicht glauben, dass die Angaben von meinem Prof. stimmen.

Der Punkt ist: Die Kleiner-Ordnung geht hier in X1 und X2 ab diesem Schritt verloren:

- Partition X into two sequences X1 and X2, such that X1 contains the 
same points as Y1 and X2 the same points as Y2.

Damit könnte ich im nächsten Schritt nicht mehr den Median von X1 und X2 finden ohne vorher nach der X-Kleiner-Ordnung in den Partitionen zu sortieren.

Der Punkt ist: Die Kleiner-Ordnung geht hier in X1 und X2 ab diesem Schritt verloren:

Wieso? Zum Partitionieren musst du doch nicht die Reihenfolge verändern.

X = { (1,4), (2,3), (3, 2), (4, 1) }

Nach y sortiert:

Y = { (4,1), (3,2), (2,3), (1,4) }

Median von Y: (3,2)

Y1 = { (4,1) }
Y2 = { (2,3), (1,4) }

Daraus folgt:

X1 = { (4,1) }
X2 = { (2,3), (1,4) }

X2 ist nun anders angeordnet und die Kleiner-Ordnung in X wird verletzt (könnte natürlich auch zufällig richtig angeordnet sein).