Question

我有以下数据结构，

self

在向量中，我正在存储typedef vector< tuple<int,int,int> > vector_tuple;

我想根据计数对矢量进行排序，如果计数相同，则根据位置对矢量进行排序。

tuple<value,count,position>

Answer 1

您的比较方法应如下所示：

auto ordering = [](const std::tuple<int, int, int>& lhs,
                   const std::tuple<int, int, int>& rhs) {
    return std::tie(std::get<1>(lhs), std::get<2>(lhs))
         < std::tie(std::get<1>(rhs), std::get<2>(rhs));
};

std::sort(std::begin(vt), std::end(vt), ordering);

Answer 2

所有归功于Jarod42的std::tie答案。

现在让我们通过创建一个可变参数模板谓词来使它成为通用的：

template<std::size_t...Is>
struct tuple_parts_ascending
{
    template<class...Ts>
    static auto sort_order(const std::tuple<Ts...>& t)
    {
        return std::tie(std::get<Is>(t)...);
    }

    template<class...Ts>
    bool operator()(const std::tuple<Ts...>& l,
                    const std::tuple<Ts...>& r) const
    {
        return sort_order(l) < sort_order(r);
    }
};

我们可以这样调用：

sort(begin(vt),end(vt),tuple_parts_ascending<1,2>());

完整代码：

#include <vector>
#include <algorithm>
#include <tuple>
#include <iostream>

using namespace std;

typedef std::vector< std::tuple<int,int,int> > vector_tuple;

template<std::size_t...Is>
struct tuple_parts_ascending
{
    template<class...Ts>
    static auto sort_order(const std::tuple<Ts...>& t)
    {
        return std::tie(std::get<Is>(t)...);
    }

    template<class...Ts>
    bool operator()(const std::tuple<Ts...>& l,
                    const std::tuple<Ts...>& r) const
    {
        return sort_order(l) < sort_order(r);
    }
};

int main()
{
    std::vector<int> v1{1,1,1,6,6,5,4,4,5,5,5};
    std::vector<int> v2(v1);
    vector_tuple vt;
    std::tuple<int,int,int> t1;
    std::vector<int>::iterator iter;
    int sizev=v1.size();
    for(int i=0; i < sizev ; i++)
    {
        auto countnu = count(begin(v2),end(v2),v1[i]);
        if(countnu > 0)
        {
            v2.erase(std::remove(begin(v2),end(v2),v1[i]),end(v2));
            auto t = std::make_tuple(v1[i], countnu, i);
            vt.push_back(t);
        }
    }
    sort(begin(vt),end(vt),tuple_parts_ascending<1,2>());


    for (int i=0; i < vt.size(); i++)
    {

        cout << get<0>(vt[i]) << " " ;
        cout << get<1>(vt[i]) << " " ;
        cout << get<2>(vt[i]) << " \n" ;
    }

}

预期结果：

更进一步，我们可以通过允许排序谓词和索引作为参数传递（这个解决方案需要c ++ 14）来使这个操作更通用和'库值'：

namespace detail {
    template<class Pred, std::size_t...Is>
    struct order_by_parts
    {
        constexpr
        order_by_parts(Pred&& pred)
        : _pred(std::move(pred))
        {}

        template<class...Ts>
        constexpr
        static auto sort_order(const std::tuple<Ts...>& t)
        {
            return std::tie(std::get<Is>(t)...);
        }

        template<class...Ts>
        constexpr
        bool operator()(const std::tuple<Ts...>& l,
                        const std::tuple<Ts...>& r) const
        {
            return _pred(sort_order(l), sort_order(r));
        }

    private:
        Pred _pred;
    };
}

template<class Pred, size_t...Is>
constexpr
auto order_by_parts(Pred&& pred, std::index_sequence<Is...>)
{
    using pred_type = std::decay_t<Pred>;
    using functor_type = detail::order_by_parts<pred_type, Is...>;
    return functor_type(std::forward<Pred>(pred));
}

现在我们可以这样排序：

sort(begin(vt),end(vt),
     order_by_parts(std::less<>(),                  // use predicate less<void>
                    std::index_sequence<1, 2>()));  // pack indices into a sequence

Answer 3

使用lambdas：

std::sort(std::begin(vt),std::end(vt),[](const auto& l,const auto& r){
    if(std::get<1>(l)== std::get<1>(r)){
         return std::get<2>(l) < std::get<2>(r);
    }
    return std::get<1>(l) < std::get<1>(r);
});

基于元组值排序矢量

3 个答案: