Question

我有这个结构：

struct Passenger
{
unsigned arrive;
unsigned depart;
};

现在我需要以相反的顺序创建A和B priority_queue。如果我重载运算符＆lt;，它们将具有相同的顺序。

我想知道，如何使用oppositi比较器创建这些优先级队列？

Answer 1

您可以为std::priority_queue指定比较器：

typedef std::priority_queue<Passenger, std::vector<Passenger>> min_queue;
typedef std::priority_queue<Passenger, std::vector<Passenger>, std::greater<Passenger>> max_queue;

或者，通用：

template <typename T, typename Container = std::vector<T>>
using min_queue = std::priority_queue<T, Container>;

template <typename T, typename Container = std::vector<T>>
using max_queue = std::priority_queue<T, Container,
        std::greater<typename Container::value_type>>;

然后：

min_queue<Passenger> my_min_queue;
max_queue<Passenger> my_max_queue;

Answer 2

我建议你研究一下boost::multi_index然后你可以有一个单一的集合，可以通过不同的方式访问。

Answer 3

创建优先级队列时需要指定比较器：

// For the moment, I'm specifying these to just compare arrival times.
// Modify that as needed.
struct GT {
    bool operator()(Passenger const &a, Passenger const &b) { 
       return b.arrive < a.arrive;
    }
};

struct LT { 
    bool operator()(Passenger const &a, Passenger const &b) { 
        return a.arrive < b.arrive;
    }
};

std::priority_queue<Passenger, std::vector<Passenger>, GT> max_heap;

std::priority_queue<Passenger, std::vector<Passenger>, LT> min_heap;

Answer 4

std::priority_queue有第二个和第三个模板参数：

第二个是底层容器，默认为std::vector
第三个是比较类，如std::map和std::set

所以你应该不重载operator<，因为这样做不会直观。相反，要实现这些比较器：

struct ArriveLess {
  bool operator()(Passenger const& lhs, Passenger const& rhs)
  { return lhs.arrive < rhs.arrive; }
};

struct DepartLess {
  bool operator()(Passenger const& lhs, Passenger const& rhs)
  { return lhs.depart < rhs.depart; }
};

/* ... */
std::priority_queue<Passenger, std::vector<Passenger>, ArriveLess> A;
std::priority_queue<Passenger, std::vector<Passenger>, std::not<ArriveLess>> B;

Answer 5

您可以将“比较”功能传递给优先级队列模板：

std::priority_queue<Passenger> A;
std::priority_queue<Passenger, std::vector<Passenger>, reverse_compare> B;

bool Passenger::reverse_compare(const Passenger& rhs)
{
  return rhs < *this;    /* Note reverse order! */
}

编辑：上面假设乘客有一个正常的operator <。

[我太慢了！]

使用相反的顺序从同一结构创建两个优先级队列

5 个答案: