#include <vector>
#include <algorithm>
#include <iterator>
#include <iostream>
#include <functional>
// iterator check
template <typename It, typename T>
constexpr bool is = std::is_same<typename std::iterator_traits<It>::iterator_category, T>::value;
// quick sort
template <typename BidIt, typename Pred = typename std::less<typename std::iterator_traits<BidIt>::value_type>>
void qsort(BidIt first, BidIt last, Pred compare = {}) noexcept
{
static_assert(is<BidIt, std::bidirectional_iterator_tag> || is<BidIt, std::random_access_iterator_tag>,
"at least bidirectional iterator required");
auto size = std::distance(first, last);
if (size > 1) {
using content_type = typename std::iterator_traits<BidIt>::value_type;
content_type pivot = *first;
std::vector<content_type> left, right;
left.reserve(size);
right.reserve(size);
auto left_end = std::back_inserter(left);
auto right_end = std::back_inserter(right);
for (BidIt i = std::next(first); i != last; ++i) {
compare(*i, pivot) ? *left_end++ = *i : *right_end++ = *i;
}
qsort(left.begin(), left.end(), compare);
qsort(right.begin(), right.end(), compare);
std::copy(left.begin(), left.end(), first);
*std::next(first, std::distance(left.begin(), left.end())) = pivot;
std::copy(right.begin(), right.end(), std::next(first, std::distance(left.begin(), left.end()) + 1));
}
}
struct integer
{
integer() = delete; //not default constructible
integer(int y):
x(y)
{}
int x;
};
bool operator<(const integer& lhs, const integer& rhs)
{
return lhs.x < rhs.x;
}
std::ostream& operator<<(std::ostream& os, const integer& x)
{
os << x.x;
return os;
}
int main() {
std::vector<integer> v{1, 0, -1, 4, 2};
qsort(v.begin(), v.end());
std::copy(v.begin(), v.end(), std::ostream_iterator<integer>(std::cout, " "));
}
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