如何排序一对向量？ [英] how to sort a vector of pairs?

问题描述

我试图排序一个向量 pair< int，T> （其中T是类的模板化值类型），codeblocks给我大量错误我不明白为什么。是有一些特殊语法需要排序向量< pair< int，T> > 吗？我没有使用比较函数，这根本没有使用T

这里是代码

  bool sortlevel（pair< int，T> a，pair< int，T> b）{
 return a.first<第一; 
} 
 
 void get_level（Node< T> * root，vector< pair< int，T>& order，int level = 0）{
 //将树更改为向量
 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& >订购; 
 get_level（root_，order）; 
 sort（order.begin（），order.end（），sortlevel）; 
 int max_level = order [order.size（） -  1]  - >第一; 
 int x = 0; 
 int current_level = order [x]  - >第一; 
 while（x< order.size（））{
 for（int y = 0; y< current_level  -  x; y ++）
 cout< \t; 
 while（order [x]  - > first == current_level）{
 cout<< order [x]  - >第二< ; 
 x ++; 
} 
} 
} 
  

解决方案>

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

  order.push_back（std :: make_pair（level，root  - > value））; 
  

另外：

  int max_level = order [order.size（） -  1]。第一; 
  

您的编译固定版本：

  #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<第一; 
} 
 
 void get_level（Node< T> * root，vector< pair< int，T>& order，int level = 0）{
 //将树更改为向量
 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& >订购; 
 get_level（root_，order）; 
 sort（order.begin（），order.end（），sortlevel）; 
 int max_level = order [order.size（） -  1]。第一; 
 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]。第二< ; 
 x ++; 
} 
} 
} 
  

在完整的代码发布之前，但可能仍然对某人试图找出排序有用，所以我会保留：
一般来说，你可能需要提供一种比较对的方式，例如，请参阅：
http://www.cplusplus.com/reference/algorithm/sort /

如果您使用排序算法，它将自动工作，对于具有小于运算符定义但不是其他类型的任何东西。

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

I am trying to sort a vector of pair<int, T> (where T is the templated value type of the class) and codeblocks is giving me massive amounts of errors i dont understand why. is there there some special syntax required to sort vector<pair<int, T> >? i did make the comparison function, which did not use T at all

here's the code

  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++;
        }
    }
  }

解决方案

The posted code didn't compile but when I was trying to make it compile I noticed you probably want:

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

Also:

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

This fixed version of yours compiles for me:

#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++;
        }
    }
  }

This part came before the full code was posted but may still be useful to someone trying to figure out sort so I'll keep it in: Generally for sorting you may need to provide a way of comparing the pairs, e.g. see here: http://www.cplusplus.com/reference/algorithm/sort/

If you use the sort algorithm it will work automagically for anything that has the less than operator defined but not for other types.

std::pair should provide a default less than operator so perhaps there is another issue - can we see the code? As Tomalak notes, that is probably because you have no way of comparing T's.

这篇关于如何排序一对向量？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！