@stryku: wtf? Twoje rozwiązania wymagają globalnego przeładowania trzech funkcji (powodzenia z posortowaniem dwóch tablic według różnych predykatów) i nie są w ogóle elastyczne. Ponadto nie powinno mieć żadnego znaczenia jaki typ jest sortowany.
@OP: to ostatnie się też tyczy Ciebie. Typ elementu tablicy i typ indeksu nie mają logicznego powiązania.
Imho najlepszym rozwiązaniem będzie opisanie wszystkich porównań za pomocą jednej funkcji, a następnie zamiana tej funkcji na predykat przekazany w parametrze.
Czyli:
T[i] < pivot
⟶ T[i] < pivot
⟶ pred(T[i], pivot)
T[j] > pivot
⟶ pivot < T[j]
⟶ pred(pivot, T[j])
Dlaczego nie ruszam i <= j
, które można opisać jako !pred(j,i)
? Ponieważ porównujesz indeksy, które powinny móc być innego typu niż element sortowanego kontenera i których porównanie nie ma się nijak do porównania elementów kontenera.
W kodzie (dodatkowo dodałem sprawdzanie, czy nie wyszedłeś za zakres, bo o tym zapomniałeś):
template <class type, typename Pred = less<type>>
void mySort (type T[], type left, type right, Pred&& p = less<type>{}) {
type i = left;
type j = right;
type pivot = T[(left + right) / 2];
do {
while (p(T[i],pivot) && i <= right)
++i;
while (p(pivot,T[j]) && j >= left)
--j;
if (i <= j) {
swap (T[i], T[j]);
++i;
--j;
}
} while (i <= j);
if (left < j) mySort(T, left, j, p);
if (right > i) mySort(T, i, right, p);
}
Przykład: http://melpon.org/wandbox/permlink/uPavqyz5wdtmi7dT
Dowód dla ostatniego sortowania: http://melpon.org/wandbox/permlink/LtYQYMNPXUhF2Ywx