如何對向量進行排序？

Question

我正在嘗試pair<int, T> （其中T是類的模板化值類型）的向量進行排序pair<int, T>而代碼塊給了我大量的錯誤，我不明白為什么。 是否有一些特殊的語法需要對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。

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 。

Answer 5

每當使用T都需要確保它在類或帶有template<typename T>的函數中。

在您的代碼中：

• 在sortlevel ， get_level和level_order的定義之前，需要template<typename T>
• 調用sort您需要對sortlevel<T>進行分類。
• 調用這些函數時，請以實際類型調用它們。