Question

我正在尝试对pair<int, T>的向量进行排序（其中T是类的模板化值类型），而codeblocks给了我大量的错误，我不明白为什么。是否需要一些特殊的语法来排序vector<pair<int, T> >？我确实做了比较功能，它根本没有使用T

这是代码

  bool sortlevel(pair<int, T> a, pair<int, T> b){
    return a.first < b.first;
  }

  void get_level(Node<T> * root, vector <pair<int, T> > & order, int level = 0){
    // changes the tree to a vector
    if (root){
        order.push_back(pair(level, root -> value));
        get_level(root -> left, order, level + 1);
        get_level(root -> right, order, level + 1);
    }
  }

  void level_order(ostream & ostr ) {
    vector<pair<int, T> > order;
    get_level(root_, order);
    sort(order.begin(), order.end(), sortlevel);
    int max_level = order[order.size() - 1] -> first;
    int x = 0;
    int current_level = order[x] -> first;
    while (x < order.size()){
        for(int y = 0; y < current_level - x; y++)
            cout << "\t";
        while (order[x] -> first == current_level){
            cout << order[x] -> second << " ";
            x++;
        }
    }
  }

Answer 1

发布的代码没有编译，但是当我尝试编译时，我注意到你可能想要：

order.push_back(std::make_pair(level, root -> value));

此外：

int max_level = order[order.size() - 1]. first;

你的编译的固定版本：

#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;

class T
{};

template <class T> class Node
{
public:
T value;
Node<T>* left;
Node<T>* right;
};

Node<T>* root_;

bool sortlevel(pair<int, T> a, pair<int, T> b){
    return a.first < b.first;
  }

  void get_level(Node<T> * root, vector <pair<int, T> > & order, int level = 0){
    // changes the tree to a vector
    if (root){
        order.push_back(std::make_pair(level, root -> value));
        get_level(root -> left, order, level + 1);
        get_level(root -> right, order, level + 1);
    }
  }

  void level_order(ostream & ostr ) {
    vector<pair<int, T> > order;
    get_level(root_, order);
    sort(order.begin(), order.end(), sortlevel);
    int max_level = order[order.size() - 1]. first;
    int x = 0;
    int current_level = order[x].first;
    while (x < order.size()){
        for(int y = 0; y < current_level - x; y++)
            cout << "\t";
        while (order[x]. first == current_level){
//            cout << order[x]. second << " ";
            x++;
        }
    }
  }

这部分是在完整代码发布之前发布的，但对于想要排序的人来说可能仍然有用，所以我会将其保留在中：通常，对于排序，您可能需要提供一种比较对的方法，例如，看这里： http://www.cplusplus.com/reference/algorithm/sort/

如果您使用排序算法，它将自动适用于具有小于运算符定义但不适用于其他类型的任何内容。

std :: pair应该提供一个默认的小于运算符，所以可能还有另一个问题 - 我们能看到代码吗？正如Tomalak所说，这可能是因为你没有办法比较T's。

Answer 2

提供您自己的比较函数（或仿函数）作为sort的最后一个参数。你的比较应该取对中的第一个并进行比较。

例如：

template<typename T>
bool myfunction (const pair<int, T>& i, const pair<int, T>& j)
{ 
   return (i.first < j.first); 
}

sort (myvector.begin(), myvector.end(), myfunction<ActualType>);

Answer 3

如果您从：

开头

#include <vector>
#include <algorithm>

struct T {
   T(int x) : x(x) {};

   int x;
};

int main() {
   std::vector<std::pair<int, T> > v;

   std::pair<int, T> a = std::make_pair(0, T(42));
   std::pair<int, T> b = std::make_pair(1, T(36));

   v.push_back(a);
   v.push_back(b);

   std::sort(v.begin(), v.end());
}

为T添加一个比较器，std::pair<int, T>默认生成的比较器将调用：

struct T {
   T(int x) : x(x) {};
   bool operator<(const T& other) const {
      return x < other.x;
   }

   int x;
};

Answer 4

看起来这些是类模板的成员函数。如果是这种情况，那么sortlevel将需要是静态的（或非成员），以便在std::sort()中用作比较器。

另外，你已经写过，例如order[x]->first在几个地方order[x].first，{{1}}。

Answer 5

每当您使用T时，您需要确保它位于类或具有template<typename T>的函数之前。

你的代码中的

：

在template<typename T>，sortlevel和get_level

level_order

致电sort时，您需要对sortlevel<T>进行分类。
调用这些函数时，请使用实际类型调用它们。

如何对一对矢量进行排序？

5 个答案: