对多个数据成员进行排序[重复]

Posted 2023-02-21

【中文标题】对多个数据成员进行排序[重复]

【英文标题】：Sorting multiple data members [duplicate]

【发布时间】：2019-06-12 18:28:39

【问题描述】：

在指针向量 (std::vector<SomeObject*) 中进行多重排序的最佳方法应该是什么？我应该为多个数据成员创建一个排序功能吗？最好的方法是什么？或者也许我应该为每个数据成员创建单独的函数？或者我应该使用std::sort() 的一些东西？ 假设我有一些带有一些数据成员的类 Vehicle

    class Vehicle
    private:
        unsigned int _maxSpeed;
        unsigned short _numberOfHorsePower;
        unsigned short _numberOfGears;
        unsigned short _numberOfWheels;
        unsigned int _weight;
    

我希望可以选择按每个数据成员对这些对象进行排序，例如 SortByMaxSpeedAsc(),SortByWeightAsc(),SortByWeightDesc()。

一个数据成员的示例排序

    void Vehicles::sortVehiclesByWeightAsc()
    
        Vehicle* tmp;
        size_t n = _VehiclesCollection.size();
        int i, j, minIndex;
    
        for (i = 0; i < n - 1; i++) 
        
            minIndex = i;
            for (j = i + 1; j < n; j++) 
            
                if (_VehiclesCollection[j].weight < _VehiclesCollection[minIndex].weight)
                
                    minIndex = j;
                
            
    
            if (minIndex != i) 
            
                tmp = _VehiclesCollection[i];
                _VehiclesCollection[i] = _VehicleCollection[minIndex];
                _VehiclesCollection[minIndex] = tmp;
            
    
        
    

【问题讨论】：

将std::sort 与自定义比较器一起使用。

您可以进行预测：coliru.stacked-crooked.com/a/1e4aa7971dd9fc2d

似乎 ts 询问多个排序，即按标准 1 单独排序的数组。并同时按标准 2 对同一数组进行排序。即独立。并且可能的重复说明了单一排序：按标准 1 和在标准 1 的相同值内也按标准 2 排序。

【参考方案1】：

使用std::sort 并为每个案例编写一个Compare 函子。如果需要合并多个字段，请使用std::tie。

这是一个例子。您不需要像我在这里所做的那样对static 成员进行排序，但它可以将std::tie 与私有成员一起使用。

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

class Vehicle 
public:
    Vehicle(unsigned maxSpeed, unsigned short numberOfHorsePower,
            unsigned short numberOfGears, unsigned short numberOfWheels,
            unsigned weight) :
        maxSpeed_(maxSpeed),
        numberOfHorsePower_(numberOfHorsePower), numberOfGears_(numberOfGears),
        numberOfWheels_(numberOfWheels), weight_(weight) 

    // you can use the accessor functions with loose sort statements if you don't
    // need to tie many columns together

    inline unsigned get_maxSpeed() const  return maxSpeed_; 
    inline unsigned short get_numberOfHorsePower() const 
        return numberOfHorsePower_;
    
    inline unsigned short get_numberOfGears() const  return numberOfGears_; 
    inline unsigned short get_numberOfWheels() const  return numberOfWheels_; 
    inline unsigned get_weight() const  return weight_; 

    // sorting functions

    template<typename It>
    static void sort_on_speed(It first, It last) 
        std::sort(first, last,
            // a lambda receiving references to two Vehicle objects to compare
            [](const Vehicle& a, const Vehicle& b) 
                // return true if a is less than b (using the field you want)
                return a.maxSpeed_ < b.maxSpeed_;
            
       );
    

    template<typename It>
    static void sort_on_hp_plus_speed(It first, It last) 
        std::sort(first, last,
            // another lambda using std::tie to sort primarily on hp
            // and secondary on speed
            [](const Vehicle& a, const Vehicle& b) 
                return std::tie(a.numberOfHorsePower_, a.maxSpeed_) <
                       std::tie(b.numberOfHorsePower_, b.maxSpeed_);
        );
    

private:
    unsigned int maxSpeed_;
    unsigned short numberOfHorsePower_;
    unsigned short numberOfGears_;
    unsigned short numberOfWheels_;
    unsigned int weight_;
;

int main() 
    std::vector<Vehicle> cars = 
        1, 2, 3, 4, 5, 2, 3, 4, 5, 1, 3, 4, 5, 1, 2
    ;

    // sort on speed
    Vehicle::sort_on_speed(cars.begin(), cars.end());

    // sort on hp + speed
    Vehicle::sort_on_hp_plus_speed(cars.begin(), cars.end());

【参考方案2】：

boost.multiindex 应该很有用。