Question

在C ++中，我想对一个冗长的（2^20）实数向量进行排序，显然sort()就可以了。在我习惯了很好的order()函数之前使用了R，它产生了导致排序向量的排列。

示例：

x = {24, 55, 22, 1}

然后排列

perm = {3, 2, 0, 1}

按升序将原始x映射到已排序的x。

我可以实现一些冒泡排序，它不仅可以排序x，而且可以在向量{0,1,2,...}上执行相同的转置并输出两者，但我相信有人必须考虑过它，特别是有效地完成了它。 / p>

Answer 1

我想说最好的方法是创建一个ints 0..N的向量，然后用比较函数对该数组进行排序，该函数比较你试图找到排序排列的向量的相应元素。类似的东西：

#include <vector>
#include <algorithm>

template<class T> class sorter {
    const std::vector<T> &values;
public:
    sorter(const std::vector<T> &v) : values(v) {}
    bool operator()(int a, int b) { return values[a] < values[b]; }
};

template<class T> std::vector<int> order(const std::vector<T> &values)
{
    std::vector<int> rv(values.size());
    int idx = 0;
    for (std::vector<int>::iterator i = rv.begin(); i != rv.end(); i++)
        *i = idx++;
    std::sort(rv.begin(), rv.end(), sorter<T>(values));
    return rv;
}

这样可以最大限度地减少分配开销，因为我们不会创建任何大型临时对象，我们会对其进行排序，然后提取最终的权限 - 返回的相同向量是排序的临时值。

Answer 2

您可以使用std::sort对对列表{（24,0），（55,2），（22,0），（1,1）}进行排序。它不是特别漂亮，但我通常做这样的事情：

#include <vector>
#include <algorithm>
#include <utility>

typedef std::pair<double, int> Pair;

struct CmpPair
{
    bool operator()(const Pair& a, const Pair& b)
    { return a.first < b.first; }
};

void sortingPermutation(
    const std::vector<double>& values,
    std::vector<int>& permutation)
{
    std::vector<Pair> pairs;
    for (int i = 0; i < (int)values.size(); i++)
        pairs.push_back(Pair(values[i], i));

    std::sort(pairs.begin(), pairs.end(), CmpPair());

    typedef std::vector<Pair>::const_iterator I;
    for (I p = pairs.begin(); p != pairs.end(); ++p)
        permutation.push_back(p->second);
}

以下是测试：

#include <iostream>

int main()
{
    std::vector<double> values;
    values.push_back(24);
    values.push_back(55);
    values.push_back(22);
    values.push_back(1);

    std::vector<int> permutation;
    sortingPermutation(values, permutation);

    typedef std::vector<int>::const_iterator I;
    for (I p = permutation.begin(); p != permutation.end(); ++p)
        std::cout << *p << " ";
    std::cout << "\n";
}

Answer 3

修改

比不使用辅助向量的方法更好：（source on ideone）：

#include <vector> #include <algorithm> #include <iostream> template<class Vals> void sortingPermutation(const Vals& values, std::vector<int>& v){ int size = values.size(); v.clear(); v.reserve(size); for(int i=0; i < size; ++i) v.push_back(i); std::sort(v.begin(), v.end(), [&values](int a, int b) -> bool { return values[a] < values[b]; }); } int main() { std::vector<double> values; values.push_back(24); values.push_back(55); values.push_back(22); values.push_back(1); std::vector<int> permutation; sortingPermutation(values, permutation); typedef std::vector<int>::const_iterator I; for (I p = permutation.begin(); p != permutation.end(); ++p) std::cout << *p << " "; std::cout << "\n"; }

我正在使用来自C ++ 0x的lambda，但它可以用简单的functor对象替换：

template<class T> struct CmpPairs{ CmpPairs(const std::vector<T> &v): v_(v) {} std::vector<T> v_; bool operator()(int a, int b){ return v_[a] < v_[b]; } }; template<class T> CmpPairs<T> CreateCmpPairs(const std::vector<T> & v) { return CmpPairs<T>(v); } //in sortingPermutation: std::sort(v.begin(), v.end(), CreateCmpPairs(values));

std::map的旧解决方案来源：ideone

对（双精度）实数的矢量进行排序并获得它们

3 个答案: