GenericSorting.h

Go to the documentation of this file.

// This file is part of CoreLibrary containing useful reusable utility
// classes.
//
// Copyright (C) 2014 to present, Duncan Crutchley
// Contact <dac1976github@outlook.com>
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published
// by the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License and GNU Lesser General Public License
// for more details.
//
// You should have received a copy of the GNU General Public License
// and GNU Lesser General Public License along with this program. If
// not, see <http://www.gnu.org/licenses/>.

#ifndef GENERICSORTING
#define GENERICSORTING

#include <functional>
#include <algorithm>
#include <utility>
#include <vector>
#include <list>
#include <iterator>
#include <stdexcept>
#include <boost/throw_exception.hpp>

namespace core_lib
{
namespace sorting
{

template <typename T, typename Pred = std::less<T>> class Bubble
{
public:
    using item_compare = Pred;

    template <typename TIterator> static void Sort(TIterator begin, TIterator end)
    {
        item_compare compare;
        bool         changesMade;

        do
        {
            changesMade = false;

            for (auto item = begin; item != end - 1; ++item)
            {
                if (compare(*(item + 1), *item))
                {
                    std::swap(*item, *(item + 1));
                    changesMade = true;
                }
            }
        } while (changesMade);
    }
};

template <typename T, typename Pred = std::less<T>> class Selection
{
public:
    using item_compare = Pred;

    template <typename TIterator> static void Sort(TIterator begin, TIterator end)
    {
        item_compare compare;
        auto         item = begin;

        while (item != end)
        {
            auto minValue = std::min_element(item, end, compare);

            if (minValue != item)
            {
                std::swap(*item, *minValue);
            }

            ++item;
        }
    }
};

template <typename T, typename Pred = std::less<T>> class Insertion
{
public:
    using item_compare = Pred;

    template <typename TIterator> static void Sort(TIterator begin, TIterator end)
    {
        item_compare compare;

        // we'll iterate over our items and for each item we'll move it to
        // the correct position in the collection inserting it and shuffling
        // the other items in the correct direction.
        for (auto item = begin; item != end; ++item)
        {
            std::rotate(std::upper_bound(begin, item, *item, compare), item, std::next(item));
        }
    }
};

template <typename T, typename Pred = std::less<T>> class Quick
{
public:
    using item_compare = Pred;

    template <typename TIterator> static void Sort(TIterator begin, TIterator end)
    {
        auto length = std::distance(begin, end);

        if (length <= 1)
        {
            return;
        }

        auto const   pivot = std::next(begin, length / 2);
        item_compare compare;
        std::nth_element(begin, pivot, end, compare);

        Sort(begin, pivot);
        Sort(std::next(pivot), end);
    }
};

template <typename T, typename Pred = std::less<T>> class Bucket
{
public:
    using item_compare = Pred;
    using bucket_definitions = std::vector<std::pair<T, T>>;
    using bucket_values = std::vector<std::list<T>>;

    template <typename TIterator>
    static void Sort(TIterator begin, TIterator end, const bucket_definitions& bucketDefinitions,
                     bucket_values& bucketValues)
    {
        if (begin >= end)
        {
            return;
        }

        PutIntoBuckets(begin, end, bucketDefinitions, bucketValues);
        WriteBackBuckets(begin, bucketValues);
        SortResult(begin, end);
    }

    template <typename TIterator>
    static void Sort(TIterator begin, TIterator end, const bucket_definitions& bucketDefinitions)
    {
        bucket_values bucketValues;
        Sort(begin, end, bucketDefinitions, bucketValues);
    }

private:
    static void CheckBucketsSize(const bucket_definitions& bucketDefinitions,
                                 bucket_values&            bucketValues)
    {
        if (bucketValues.size() != bucketDefinitions.size())
        {
            bucketValues.resize(bucketDefinitions.size());
        }
    }

    static size_t GetBucketIndex(const T& value, const bucket_definitions& bucketDefinitions)
    {
        size_t index{};

        for (const auto& bucket : bucketDefinitions)
        {
            if ((value >= bucket.first) && (value <= bucket.second))
            {
                break;
            }

            ++index;
        }

        if (index == bucketDefinitions.size())
        {
            BOOST_THROW_EXCEPTION(std::runtime_error("bucket not found"));
        }

        return index;
    }

    template <typename TIterator>
    static void PutIntoBuckets(TIterator begin, TIterator end,
                               const bucket_definitions& bucketDefinitions,
                               bucket_values&            bucketValues)
    {
        CheckBucketsSize(bucketDefinitions, bucketValues);

        for (auto item = begin; item != end; ++item)
        {
            size_t bucketIndex{GetBucketIndex(*item, bucketDefinitions)};
            bucketValues[bucketIndex].emplace_back(*item);
        }
    }

    template <typename TIterator>
    static void WriteBackBuckets(TIterator begin, const bucket_values& bucketValues)
    {
        TIterator pos{begin};

        for (auto& bucket : bucketValues)
        {
            std::move(bucket.begin(), bucket.end(), pos);
            pos += bucket.size();
        }
    }

    template <typename TIterator> static void SortResult(TIterator begin, TIterator end)
    {
        Insertion<T, item_compare>::Sort(begin, end);
    }
};

} // namespace sorting
} // namespace core_lib

#endif // GENERICSORTING