C++容器之优先队列(std::priority_queue)_std 优先队列

1 概述

  优先级队列是一种容器适配器，专门设计为根据一些严格的弱排序标准，它的第一个元素始终是它所包含的元素中最大的一个。
  此上下文类似于堆(heap)，在堆中，元素可以随时插入，并且只能检索最大堆元素（优先级队列中最顶端的元素）。
  优先级队列被实现为容器适配器，容器适配器是使用特定容器类的封装对象作为其底层容器的类，提供一组特定的成员函数来访问其元素。元素从特定容器的“后部”弹出，即优先级队列的顶部。
  底层容器可以是任何标准容器类模板或某些其他专门设计的容器类。容器应可通过随机访问迭代器访问，并支持以下操作：

• empty 是否为空
• size 队列大小
• front 队首元素
• push_back 入队
• pop_back 出队
    标准容器类vector和deque满足这些要求。默认情况下，如果没有为特定的priority_queue类实例化指定容器类，则使用标准容器向量(vector)。
    需要支持随机访问迭代器才能始终在内部保持堆结构。这是由容器适配器在需要时自动调用算法函数make_heap、push_heap和pop_heap来自动完成的。
  其类图如下:
  

2 使用实例

void PriorityQueueSuite::pop()
{
    std::priority_queue<int> a;

    a.push(30);
    a.push(100);
    a.push(20);
    a.push(40);

    TEST_ASSERT_EQUALS(100, a.top())
    a.pop();
    TEST_ASSERT_EQUALS(40, a.top())

    a.pop();
    TEST_ASSERT_EQUALS(30, a.top())

    a.pop();
    TEST_ASSERT_EQUALS(20, a.top())

    if(!a.empty())
        a.pop();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

3 接口使用

3.1 construct

class queuecomparison
{
  bool reverse;
public:
  queuecomparison(const bool& r = false) : reverse(r){}
  bool operator() (const int& l, const int&r) const { return reverse ? (l > r) :(l < r); }
};
#define ARRAY_SIZE(array) sizeof(array) / sizeof(array[0])
void PriorityQueueSuite::construct()
{
    int array[] = { 20, 70, 60, 25 };
    std::priority_queue<int> a;
    std::priority_queue<int> b(array, array + ARRAY_SIZE(array));
    std::priority_queue<int, std::vector<int>, std::greater<int>> c(array, array + ARRAY_SIZE(array));
    std::priority_queue<int, std::vector<int>, queuecomparison> d(array, array + ARRAY_SIZE(array));
    std::priority_queue<int, std::vector<int>, queuecomparison> e(array, array + ARRAY_SIZE(array), queuecomparison(true));

    TEST_ASSERT_EQUALS(0, a.size())
    TEST_ASSERT_EQUALS(4, b.size())
    TEST_ASSERT_EQUALS(4, c.size())
    TEST_ASSERT_EQUALS(4, d.size())
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

说明：

• 可以设置比较函数，如果比较函数是小于,top返回最大值，如果比较函数是大于，top返回最小值

3.2 empty

void PriorityQueueSuite::empty()
{
    int array[] = { 20, 70, 60, 25 };
    std::priority_queue<int> a;
    std::priority_queue<int> b(array, array + ARRAY_SIZE(array));

    TEST_ASSERT_EQUALS(true, a.empty())
    TEST_ASSERT_EQUALS(false, b.empty())
}
1
2
3
4
5
6
7
8
9

3.3 size

void PriorityQueueSuite::size()
{
    int array[] = { 20, 70, 60, 25 };
    std::priority_queue<int> a;
    std::priority_queue<int> b(array, array + ARRAY_SIZE(array));

    TEST_ASSERT_EQUALS(0, a.size())
    TEST_ASSERT_EQUALS(4, b.size())
}
1
2
3
4
5
6
7
8
9

3.4 top

void PriorityQueueSuite::top()
{
    int array[] = { 20, 70, 60, 25 };
    std::priority_queue<int> a;
    std::priority_queue<int> b(array, array + ARRAY_SIZE(array));
    std::priority_queue<int, std::vector<int>, std::greater<int>> c(array, array + ARRAY_SIZE(array));
    std::priority_queue<int, std::vector<int>, queuecomparison> d(array, array + ARRAY_SIZE(array));
    std::priority_queue<int, std::vector<int>, queuecomparison> e(array, array + ARRAY_SIZE(array), queuecomparison(true));
    std::priority_queue<int> f(b);
    std::priority_queue<int> g(std::priority_queue<int>(array, array + ARRAY_SIZE(array)));

    if(!a.empty())
        TEST_ASSERT_EQUALS(60, a.top())

    TEST_ASSERT_EQUALS(70, b.top())
    TEST_ASSERT_EQUALS(20, c.top())
    TEST_ASSERT_EQUALS(70, d.top())
    TEST_ASSERT_EQUALS(20, e.top())
    TEST_ASSERT_EQUALS(70, f.top())
    TEST_ASSERT_EQUALS(70, g.top())
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

说明:

• 返回队列头元素
• 如果比较函数是小于，返回的是最大值，默认比较函数是小于
• 如果比较函数是大于，返回的是最小值

3.5 push

void PriorityQueueSuite::push()
{
    std::priority_queue<int> a;

    a.push(30);
    TEST_ASSERT_EQUALS(30, a.top())
    a.push(100);
    TEST_ASSERT_EQUALS(100, a.top())
    a.push(25);
    TEST_ASSERT_EQUALS(100, a.top())
    a.push(40);
    TEST_ASSERT_EQUALS(100, a.top())
}
1
2
3
4
5
6
7
8
9
10
11
12
13

3.6 emplace

void PriorityQueueSuite::emplace()
{
    std::priority_queue<std::string> fruits;

    fruits.emplace("orange");
    fruits.emplace("strawberry");
    fruits.emplace("apple");
    fruits.emplace("pear");
    TEST_ASSERT_EQUALS(4, fruits.size())
}
1
2
3
4
5
6
7
8
9
10

3.7 pop

void PriorityQueueSuite::pop()
{
    std::priority_queue<int> a;

    a.push(30);
    a.push(100);
    a.push(20);
    a.push(40);

    TEST_ASSERT_EQUALS(100, a.top())
    a.pop();
    TEST_ASSERT_EQUALS(40, a.top())

    a.pop();
    TEST_ASSERT_EQUALS(30, a.top())

    a.pop();
    TEST_ASSERT_EQUALS(20, a.top())

    if(!a.empty())
        a.pop();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

3.8 swap

void PriorityQueueSuite::swap()
{
    int array[] = { 20, 70, 60, 25 };
    std::priority_queue<int> a;
    std::priority_queue<int> b(array, array + ARRAY_SIZE(array));

    TEST_ASSERT_EQUALS(0, a.size())
    TEST_ASSERT_EQUALS(4, b.size())

    a.swap(b);
    TEST_ASSERT_EQUALS(4, a.size())
    TEST_ASSERT_EQUALS(0, b.size())
}
1
2
3
4
5
6
7
8
9
10
11
12
13