prority_queue

1. 优先队列是一种容器适配器。

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

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

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

empty()：检测容器是否为空;

size()：返回容器中有效元素个数;

front()：返回容器中第一个元素的引用;

push_back()：在容器尾部插入元素;

pop_back()：删除容器尾部元素。

下面是prority_queue的模拟实现：

#pragma once
#include
namespace y

{
    template//less与Greater不一定要与这里相同
    class Less
    {
    public:
        bool operator()(const T& x, const T& y)
        {
            return x < y;
        }
    };

    template
    class Greater
    {
    public:
        bool operator()(const T& x, const T& y)
        {
            return x > y;
        }
    };

    template , class Compare = std::less >

    class priority_queue

    {

    public:

        priority_queue()
        {}

        template 

        priority_queue(InputIterator first, InputIterator last)
            :c(first, last)
        {
            for (int i = (c.size() - 2) / 2; i >= 0; --i)
            {
                adjust_down(i);
            }
        }


        void adjust_down(int parent)//向下调整
        {
            //Compare comp{};
            int child = parent * 2 + 1;
            while (child < c.size())
            {
                if (child+1 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;

    };

};

void test_priority_queue()//测试函数
{
    // 插入删除数据效率 logN
    y::priority_queue q; // 大堆
    y::priority_queue, less> q1; // 大堆
    y::priority_queue, greater> q2; // 小堆

    q.push(3);
    q.push(1);
    q.push(5);
    q.push(4);

    
    while (!q.empty())
    {
        cout << q.top() << " ";
        q.pop();
    }
    cout << endl;

}