C++优先级队列priority_queue的模拟实现

1.优先级队列的模拟实现

优先级队列默认使用vector作为其底层存储数据的容器，在vector上又使用了堆算法将vector中元素构造成堆的结构，因此priority_queue就是堆。

#pragma once
#include<vector>
#include<iostream>
#include<functional>
#include <algorithm>
using namespace std;
namespace my
{
template<class T, class Container = vector<T>, class Compare = less<T>>
class priority_queue
{
public:
priority_queue()
{}

        template<class InputIterator>
priority_queue(InputIterator first, InputIterator last)
{
while (first != last)
{
_con.push_back(*first);
++first;
}
//向下调整建堆
for (int i = (_con.size() - 2) / 2; i >= 0; i--)
{
AdjustDown(i);
}
}

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

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

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

        bool empty()
{
return _con.empty();
}

        size_t size()
{
return _con.size();
}
private:
void AdjustDown(int parent)
{
Compare com;

            int child = parent * 2 + 1;
while (child < _con.size())
{
if (child + 1 < _con.size() && com(_con[child], _con[child + 1]))
{
child++;
}

                if (com(_con[parent], _con[child]))
{
swap(_con[parent], _con[child]);
parent = child;
child = parent * 2 + 1;
}
else
{
break;
}
}
}

        void AdjustUp(int child)
{
Compare com;

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

}
}
Container _con;
};

    void test_priority_queue1()
{
// 默认是大堆 -- less
//priority_queue<int> pq;
//小堆
priority_queue<int,vector<int>,greater<int>> pq;

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

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

2.仿函数/函数对象

template<class T, class Container = vector<T>, class Compare = less<T>>

优先级队列中的三个模板参数中，第三个传递的就是仿函数，可以自己定义实现仿函数的内容来控制优先级的变化。

仿函数本质上是一个类，该类定义了函数调用运算符 operator()，当创建该类的对象后，就可以像调用普通函数一样使用该对象。

对于上述的优先级队列，我们也可以自己实现仿函数，调用自己的比较器。

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