C++ 如何在优先级队列中找到值？

我想在优先级队列中查找节点，但未找到解决方案：( 如果你有解决办法，我很感兴趣

---

THX求助。

< P>如果您不关心性能，可以声明迭代器< /C> >遍历PrimeRySeQuey的容器。但是在C++中，基础容器被声明为“代码>保护< /代码>，不能直接访问。< /P> 我获取容器迭代器的一个解决方案是声明一个从

std:：priority\u queue

继承的新类

typedef int Val_TYPE;
typedef vector<Val_TYPE> Container_TYPE;
typedef priority_queue<Val_TYPE, Container_TYPE> pri_queue;

class Queue: public pri_queue{
public:
    Container_TYPE::iterator begin(){
        return pri_queue::c.begin();
    }
    Container_TYPE::iterator end(){
        return pri_queue::c.end();
    }
}Q;

将所有数据存储在单独的集合中，例如数组或链接列表

Data data[MAX]; 

定义一个新的结构，该结构存储特定对象的指针

data[i]

struct Node{
    Data* data;
    Node(Data* ptr){data=ptr;}
};

使用

优先级队列

和另一个支持搜索的数据结构，即

二进制搜索树

，

哈希

。这里我使用

多重映射

同时维护

节点的
优先级队列
和
节点的
多重映射

struct cmp1{
    bool operator(Node a, Node b){ return a.data->value < b.data->value; }
};

struct cmp2{
    bool operator(Node a, Node b){ return a.data->key < b.data->key; }
};

priority_queue<Node, vector<Node>, cmp1> q;

multimap <KEY_TYPE, Node, cmp2> d;

for(int i = 0; i < n; ++i){
    q.push(Node(&a[i]));
    d.insert(a[i].key, Node(&a[i]));
}

struct cmp1{
布尔运算符（节点a，节点b）{返回a.data->valuevalue；}
};
结构cmp2{
布尔运算符（节点a，节点b）{返回a.data->keykey；}
};
优先级队列q；
多重映射d；
对于（int i=0；i

然后，您可以使用multimap
d
通过键获取数据的
指针。使用priority\u queue
q
也可以满足优先级队列的需要

以上所有操作都只是使用指针。
如果您确实需要在
std:：priority\u队列中进行搜索，并希望高效地进行搜索，您可以派生一个新类并添加一个
find
成员函数。由于您没有添加任何附加状态，因此不必担心切片或其他问题，因为
std:：priority_队列
不是多态的

#include <queue>
template<
    class T,
    class Container = std::vector<T>,
    class Compare = std::less<typename Container::value_type>
> class MyQueue : public std::priority_queue<T, Container, Compare>
{
public:
    typedef typename
        std::priority_queue<
        T,
        Container,
        Compare>::container_type::const_iterator const_iterator;

    const_iterator find(const T&val) const
    {
        auto first = this->c.cbegin();
        auto last = this->c.cend();
        while (first!=last) {
            if (*first==val) return first;
            ++first;
        }
        return last;
    }
};

#包括
模板<
T类，
类容器=std:：vector，
类比较=std:：less
>类MyQueue:public std:：priority\u队列
{
公众：
typedef typename
std：：优先级队列<
T
集装箱，
比较>：：容器类型：：常量迭代器常量迭代器；
常量迭代器查找（常量T&val）常量
{
自动优先=此->c.cbegin（）；
自动上次=此->c.cend（）；
while（第一个！=最后一个）{
如果（*first==val），则首先返回；
++第一,；
}
最后返回；
}
};
没有任何代码？很好的尝试…一个
priority\u队列
只定义了两个操作：以给定的优先级插入，然后检索具有最高优先级的项目。如果您还需要其他内容，
priority\u队列
不是合适的容器。它将有助于了解您需要它的目的–优先级队列的全部用途是n通常情况下，您不需要此操作。@syam如果您需要知道特定元素的当前优先级是什么，该怎么办。
int priority=pq.find（）-pg.begin（）
你能提供更多关于你需要的信息吗？你不需要包括比较函数。对于
map
和
priority\u queue
来说，模板参数默认为
std:：less
。
captainious可能你不理解我。我的意思是使用
priority\u queue
和
multimap
来存储数据的
指针
。因此我需要编写自己的比较函数。使用两个容器是不必要的，即使使用比较函数，也会导致它们的顺序不同。将比较函数移动到
节点
中，则需要处理一个不太明确的依赖项。将键和值都存储在
Data
是不必要的，它已经由容器管理。您最好编写自己的容器适配器。不需要定义一个新类，然后对其进行迭代。同样，也可以将其传递给一个函数，该函数将弹出并搜索队列中的元素。问一下，这是什么->c？
c
下面的容器。它是“代码>容器”/Cudio的类型，作为模板参数传递，并在C++语言标准中指定，因此它保证始终存在。对于C++和标准库来说是一个很好的例子。是的，我一眼就看到了，谢谢。
struct cmp1{
    bool operator(Node a, Node b){ return a.data->value < b.data->value; }
};

struct cmp2{
    bool operator(Node a, Node b){ return a.data->key < b.data->key; }
};

priority_queue<Node, vector<Node>, cmp1> q;

multimap <KEY_TYPE, Node, cmp2> d;

for(int i = 0; i < n; ++i){
    q.push(Node(&a[i]));
    d.insert(a[i].key, Node(&a[i]));
}

#include <queue>
template<
    class T,
    class Container = std::vector<T>,
    class Compare = std::less<typename Container::value_type>
> class MyQueue : public std::priority_queue<T, Container, Compare>
{
public:
    typedef typename
        std::priority_queue<
        T,
        Container,
        Compare>::container_type::const_iterator const_iterator;

    const_iterator find(const T&val) const
    {
        auto first = this->c.cbegin();
        auto last = this->c.cend();
        while (first!=last) {
            if (*first==val) return first;
            ++first;
        }
        return last;
    }
};