优先级队列

目录

前言

1.容器适配器

1.1什么是适配器

1.2STL标准库中stack和queue的底层结构

1.3deque的原理介绍 

1.3.1deque的缺陷

1.4为什么选择deque作为stack和queue的底层默认容器

2.priority_queue的介绍和使用

2.1priority_queue的介绍

2.2priority_queue的使用

3.仿函数

总结

---

前言

        在本篇文章中，我们将详细介绍优先级队列、了解适配器和仿函数。

---

1.容器适配器

1.1什么是适配器

适配器是一种设计模式(设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结)，该种模式是将一个类的接口转换成客户希望的另外一个接口。

1.2STL标准库中stack和queue的底层结构

虽然stack和queue中也可以存放元素，但在STL中并没有将其划分在容器的行列，而是将其称为容器适配器，这是因为stack和队列只是对其他容器的接口进行了包装，STL中stack和queue默认使用deque。

1.3deque的原理介绍 

deque(双端队列)：是一种双开口的"连续"空间的数据结构，双开口的含义是：可以在头尾两端进行插入和删除操作，且时间复杂度为O(1)，与vector比较，头插效率高，不需要搬移元素；与list比较，空间利用率比较高。

deque并不是真正连续的空间，而是由一段段连续的小空间拼接而成的，实际deque类似于一个动态的二维数组

1.3.1deque的缺陷

与vector比较，deque的优势是：头部插入和删除时，不需要搬移元素，效率特别高，而且在扩容时，也不需要搬移大量的元素，因此其效率是必vector高的。

与list比较，其底层是连续空间，空间利用率比较高，不需要存储额外字段。

但是，deque有一个致命缺陷：不适合遍历，因为在遍历时，deque的迭代器要频繁的去检测其是否移动到某段小空间的边界，导致效率低下，而序列式场景中，可能需要经常遍历，因此在实际中，需要线性结构时，大多数情况下优先考虑vector和list，deque的应用并不多，而目前能看到的一个应用就是，STL用其作为stack和queue的底层数据结构。

1.4为什么选择deque作为stack和queue的底层默认容器

 1. stack和queue不需要遍历(因此stack和queue没有迭代器)，只需要在固定的一端或者两端进行操作。

2. 在stack中元素增长时，deque比vector的效率高(扩容时不需要搬移大量数据)；queue中的元素增长时，deque不仅效率高，而且内存使用率高。

2.priority_queue的介绍和使用

2.1priority_queue的介绍

1. 优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。

2. 此上下文类似于堆，在堆中可以随时插入元素，并且只能检索最大堆元素(优先队列中位于顶部的元素)。

3. 优先队列被实现为容器适配器，容器适配器即将特定容器类封装作为其底层容器类，queue提供一组特定的成员函数来访问其元素。元素从特定容器的“尾部”弹出，其称为优先队列的顶部。

4. 底层容器可以是任何标准容器类模板，也可以是其他特定设计的容器类。容器应该可以通过随机访问迭代器访问，并支持以下操作：

empty()；        size()；        front()；        push_back()；        pop_back()；

5标准容器类vector和deque满足这些需求。默认情况下，如果没有为特定的priority_queue类实例化指定容器类，则使用vector。

6. 需要支持随机访问迭代器，以便始终在内部保持堆结构。容器适配器通过在需要时自动调用算法函数make_heap、push_heap和pop_heap来自动完成此操作。

2.2priority_queue的使用

优先级队列默认使用vector作为其底层存储数据的容器，在vector上又使用了堆算法将vector中元素构造成堆的结构，因此priority_queue就是堆，所有需要用到堆的位置，都可以考虑使用priority_queue。注意： 默认情况下priority_queue是大堆。

我们对优先级队列做一些简单实现

template <class T, class Container = vector<T>>
    class priority_queue
    {
    public: 
        bool empty() const
        {
            return _c.empty();
        }

        size_t size() const
        {
            return _c.size();
        }

        const T& top() const
        {
            return _c[0];
        }

        void push(const T& x)
        {
            _c.push_back(x);
            adjust_up(_c.size()-1);
        }

        void pop()
        {
            swap(_c[0], _c[_c.size() - 1]);
            _c.pop_back();
            adjust_down(0);
        }

    private:
        Container _c;
    };

因为是堆的结构，所以我们需要实现一些插入和删除所需要的调整

void adjust_down(int parent)
{
    int child = parent * 2 + 1;
    while (child < _c.size())
    {
        if (child + 1 < _c.size() && _c[child ] < _c[child+1])
        {
            ++child;
        }
        if (_c[parent] < _c[child])
        {
            swap(_c[parent], _c[child]);
            parent = child;
            child = parent * 2 + 1;
        }
        else 
        {
            break;
        }
    }           
}

void adjust_up(int child)
{
    int parent = (child - 1) / 2;
    while (child > 0)
    {
        if (_c[parent]< _c[child])
        {
            swap(_c[parent], _c[child]);
            child = parent;
            parent = (child - 1) / 2;
        }
        else
        {
            break;
        }
    }
}

因为默认的是大堆，所以我们这边实现的是大堆，但是我们可以想一下我们要是想要小堆怎么办，难道又回来改吗，这个时候可以改，但是是谁都可以谁都知道只能改吗？明显是不行的，这个时候就需要一个能够实现不用自己去改又能实现里面大小变换的东西了，那么这个时候就会用到我们的仿函数了

3.仿函数

在C++中，仿函数通常是一个类，实现了重载()运算符（也称为函数调用运算符），使得该类的对象可以像函数一样被调用。仿函数类通常包含一个或多个成员变量，用于保存外部传入的状态或参数，这些成员变量可以在调用时起到类似于函数闭包的作用。

仿函数的使用方式类似于函数指针，可以作为参数传递给其他函数，也可以作为一种返回值类型。而与函数指针不同的是，仿函数类型具有明确的类型信息，因此可以实现更加严格的类型校验，同时还可以利用C++模板机制实现泛型编程，让代码更具通用性和可重用性。

下面是一个简单的仿函数示例，它实现了一个将输入整数加倍的操作：

class Doubler {
public:
    int operator()(int x) const {
        return 2 * x;
    }
};

Doubler doubler;
int x = doubler(3); // x = 6

在上面的示例中，类Doubler实现了重载()运算符，该运算符接受一个整数参数，并返回它的两倍。通过创建类的一个实例（doubler），我们可以像调用函数一样使用仿函数，将3作为参数传入，得到6作为结果。

我们了解了仿函数之后，我们把仿函数加在优先级队列中

template<class T>
struct less
{
    bool operator()(const T& x, const T& y)
    {
        return x < y;
    }
};

template<class T>
struct greater
{
    bool operator()(const T& x, const T& y)
    {
        return x > y;
    }
};

template <class T, class Container = vector<T>, class Compare = less<T> >
class priority_queue
{
public:
    void adjust_down(int parent)
    {
        int child = parent * 2 + 1;
        while (child < _c.size())
        {
            if (child + 1 < _c.size() && _comp(_c[child], _c[child + 1]))
            {
                ++child;
            }
            if (_comp(_c[parent], _c[child]))
            {
                swap(_c[parent], _c[child]);
                parent = child;
                child = parent * 2 + 1;
            }
            else
            {
                break;
            }
        }        
    }

    void adjust_up(int child)
    {
        int parent = (child - 1) / 2;

        while (child > 0)
        {
            if (_comp(_c[parent], _c[child]))
            {
                swap(_c[parent], _c[child]);
                child = parent;
                parent = (child - 1) / 2;
            }
            else
            {
                break;
            }
        }
    }

    bool empty() const
    {
        return _c.empty();
    }

    size_t size() const
    {
        return _c.size();
    }

    const T& top() const
    {
        return _c[0];
    }

    void push(const T& x)
    {
        _c.push_back(x);
        adjust_up(_c.size() - 1);
    }

    void pop()
    {
        swap(_c[0], _c[_c.size() - 1]);
        _c.pop_back();
        adjust_down(0);
    }

private:
    Container _c;
    Compare _comp;
};

这样优先级队列就实现了

---

总结

        以上就是今天要讲的内容，在本篇博客中，我们详细介绍了优先级队列的概念和实现方式。以下是本篇博客的总结：

1. 优先级队列是一种特殊的队列，可以根据元素的优先级来确定元素的顺序。

2. 堆是实现优先级队列的基本数据结构，最大堆和最小堆是常见的堆类型。

3. 优先级队列可以用于各种场景，例如任务调度、网络路由和模拟事件。

        总之，优先级队列是一种非常重要的数据结构，它可以帮助我们解决各种实际问题，具有广泛的应用前景，除此之外我们还介绍了适配器和仿函数，他们能过帮我们更好的实现各种问题，希望这篇文章对大家的学习有所帮助。

        感谢大家的支持，我们下篇文章再见！！！