实现可以在C ++中迭代的优先级队列

Question

I need to implement a priority queue for a project, but the STL's priority_queue is not indicated since we need to iterate over all elements and remove them randomly.

We are thinking about using the STL's set for this, wrapping it in a class to make it an ADT.

Is there a smarter solution for this?

How can we make it so some of set 's public member functions can be used publicly? We're interested in iterators, etc.

Apparently deriving the STL is unwise because of the lack of virtual destructors :/

---

New code:

#ifndef PRIORITYQUEUE_H_
#define PRIORITYQUEUE_H_

#include <set>

template<typename T, template<typename X> class impl_type = std::set>
class PriorityQueue {
    typedef impl_type<T> set_type;
    typedef typename set_type::iterator iterator;
public:
    void push(const T& x) {
        insert(x);

    }

    void pop() {
        erase(begin());
    }

    const T& top() const {
        return *begin();
    }
};

#endif /* PRIORITYQUEUE_H_ */

So, we currently have this. The compiler doesn't complain about insert, but it does complain about erase(begin()) and return *begin() :

there are no arguments to 'begin' that depend on a template parameter, so a declaration of 'begin' must be available

Why is this?

Answer 1

You should be able to implement your own priority queue using std::vector , std::make_heap , std::push_heap , and std::pop_heap . Isn't this how std::priority_queue is implemented? You'll just need to call std::make_heap again to fix the data structure when you remove a random element.

Do you need to iterate over the elements in order? There's a std::sort_heap algorithm to order the underlying std::vector .

Answer 2

Do you really need a priority queue ?

You need iterate over all items and remove randomly -> linked list

If you need to keep the list sorted, sort it at the beginning and then, when inserting new item, use insertion sort (insert new item on right place).

Answer 3

STL's set should be usable to make what you want, although I must note that the list of requirements looks a little strange. You could just define a new type.

template<typename T, template<typename X> class impl_type = std::set> class prio_queue {
    typedef impl_type<T> set_type;
    typedef typename set_type::iterator iterator;
    // etc
public:
    // Forward the set's members
    T& top() {
        return *begin();
    }
    // etc
};

Answer 4

I would follow the example set by some of the other container adapters in the standard library use composition and make the type of the underlying container a template parameter. Though since it is a school project that might be too much flexibility. You might start by using composition with one of the existing Containers and build from there if necessary.