aca-tasks/task2/include/quicksort_mt.h

#include <vector>
#include <span>
#include <thread>
#include <mutex>
#include <functional>
#include <assert.h>

template<typename T>
class QuickSorterMT {
public:
    template<typename C>
    QuickSorterMT(C cmp, int max_depth) : cmp(cmp), max_depth(max_depth) {
        static_assert(std::is_same<std::invoke_result_t<C, T, T>, bool>(), "C must be a function that returns a bool");
    }

    auto sort(std::vector<T> &data) -> void {
        std::span<T> sortable(data);
        qsort(sortable, 0, max_depth);
    }

private:
    auto parition(std::span<T> &data) -> std::pair<std::span<T>, std::span<T>> {
        auto pivot = data.begin();
        std::advance(pivot, std::distance(data.begin(), data.end()) / 2);

        auto lefti = data.begin();
        auto righti = data.end() - 1;

        while (1) {
            for (; cmp((*lefti), (*pivot)); lefti++);
            for (; !cmp((*righti), (*pivot)); righti--);

            if (lefti >= righti) {
                break;
            }

            std::swap(*lefti, *righti);
        }

        return {std::span<T>(data.begin(), pivot), std::span<T>(pivot, data.end())};
    }


    auto qsort(std::span<T> &data, int depth, const int &mdepth) -> void {
        if (std::distance(data.begin(), data.end()) <= 1) {
            return;
        } else if (std::distance(data.begin(), data.end()) == 2) {
            if (cmp(data[1], data[0])) {
                std::swap(data[0], data[1]);
                return;
            }
        }
        auto pivot = *std::next(data.begin(), std::distance(data.begin(), data.end()) / 2);

        auto m1 = std::partition(data.begin(), data.end(), [pivot, this](const auto &em) {
            return this->cmp(pivot, em);
        });

        auto m2 = std::partition(m1, data.end(), [pivot, this](const auto &em) {
            return !(this->cmp(em, pivot));
        });

        auto left = data.subspan(0, m1 - data.begin());
        auto right = data.subspan(m2 - data.begin());

        if (depth < mdepth) {
            std::thread left_thread([&]() { qsort(left, depth + 1, mdepth); });
            std::thread right_thread([&]() { qsort(right, depth + 1, mdepth); });

            left_thread.join();
            right_thread.join();
        } else {
            qsort(left, depth + 1, mdepth);
            qsort(right, depth + 1, mdepth);
        }
    }

    std::function<bool(T, T)> cmp;
    const int max_depth;
};