目录
一、优先级队列
1、priority_queue 的介绍
2、priority_queue 的使用
3、 priority_queue 的模拟实现
1）priority_queue()/priority_queue(first, last)
2）push（x）
3）pop（）
4） top（）
5) empty （）
6）size （）
二、仿函数
1、定义
三、完整代码
四、反向迭代器
1、重新定义一个类
2、复用正向迭代器
3、完整代码
一、优先级队列
1、priority_queue 的介绍
⭕ 优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。
⭕ 此上下文类似于堆，在堆中可以随时插入元素，并且只能检索最大堆元素(优先队列中位于顶部的元素)。
⭕优先队列被实现为容器适配器，容器适配器即将特定容器类封装作为其底层容器类，queue提供一组特定的成员函数来访问其元素。元素从特定容器的“尾部”弹出，其称为优先队列的顶部。
⭕底层容器可以是任何标准容器类模板，也可以是其他特定设计的容器类。容器应该可以通过随机访问迭代器访问，并支持以下操作：
empty()：检测容器是否为空
size()：返回容器中有效元素个数
front()：返回容器中第一个元素的引用
push_back()：在容器尾部插入元素
pop_back()：删除容器尾部元素
⭕标准容器类vector和deque满足这些需求。默认情况下，如果没有为特定的priority_queue
⭕ 需要支持随机访问迭代器，以便始终在内部保持堆结构。容器适配器通过在需要时自动调用算法函数 make_heap、push_heap和pop_heap来自动完成此操作。
【优先级队列的官方文档】
2、priority_queue 的使用
优先级队列默认使用 vector 作为其底层存储数据的容器，在 vector上又使用了堆算法将 vector 中元素构造成堆的结构，因此priority_queue就是堆，所有需要用到堆的位置，都可以考虑使用priority_queue。注意： 默认情况下priority_queue是大堆
1）priority_queue()/priority_queue(first, last)
功能：构造一个空的优先级队列。
2）empty（）
功能：检测优先级队列是否为空，是返回true，否则返回 false
3）top ()
功能：返回优先级队列最大（或最小）元素，即堆顶元素
4）push（x）
功能：在优先级队列中插入元素x
5）pop（）
功能：删除优先级队列最大（或最小）元素，即堆顶元素
如果在priority_queue中放自定义类型的数据，用户需要在自定义类型中提供 > 或者< 的重载。
3、 priority_queue 的模拟实现
通过对 priority_queue 的底层结构就是堆，因此此处只需对对进行通用的封装即可。其底层本质是一个二叉树的堆，使用 vector 来构建，再加上堆的算法，将这个线性表构建成堆的结构。
1）priority_queue()/priority_queue(first, last)
优先级队列实例化出的对象本身就是一个堆，所以我们需要在它的构造函数里就将建堆工作做好。不像前面的stack和queue我们不需要写构造函数的，因为自定义成员变量，初始化时，会调用默认构造函数或者它自己的构造函数。而这里构造函数需要构造出一个堆，需要我们自己手动操作了。
优先级队列可以使用迭代器来初始化：
2）push（x）
先插入一个数据到数组里，但是需要保留堆的结构，我们可以使用向上调整法。
3）pop（）
删除堆顶元素，直接删除会破坏堆的结构。可以将堆顶元素和最后一个元素相交换，删除最后一个元素，将堆顶元素向下调整。
4） top（）
返回堆顶元素。直接返回 _con 下标为0的值。
5) empty （）
检查优先级队列是否为空，直接判断 _con 是否为空即可。
6）size （）
返回优先级队列的个数，返回 _con 的个数即可
二、仿函数
1、定义
仿函数(functor)，就是使一个类或者结构体的使用看上去像一个函数。其实现就是类中重载 operator() 运算符，这个类就有了类似函数的行为，类的对象可以像函数一样使用。
我们在模拟实现优先级队列时会发现，我们只模拟了默认大堆的实现方式，如果要模拟实现小堆，难道要再重新写一份相同的代码吗？我们可以使用仿函数控制比较,进而控制大堆还是小堆，再增加一个模板参数用来传递仿函数，仿函数可以控制比较方式。这样就可以灵活的传递仿函数来控制创建大堆还是小堆。
三、完整代码
namespace zhou
{
template<class T>
class Less
{
public:
bool operator()(T& x, T& y)//重载()运算符
{
return x < y;
}
};
template<class T>
class Greater
{
public:
bool operator()(T& x, T& y)//重载()
{
return x > y;
}
};
template<class T, class Container = vector<T>, class Comapre = less<T>>
class priority_queue
{
public:
void Adjustdown(int parent)
{
size_t child = 2 * parent + 1;
while (child < _con.size())
{
//if (child + 1 < _con.size() && _con[child] < _con[child + 1)
if (child + 1 < _con.size()
&& com(_con[child], _con[child + 1]))
{
child++;
}
if (_con[parent] < _con[child])
{
swap(_con[parent], _con[child]);
parent = child;
child = 2 * parent + 1;
}
else
{
break;
}
}
}
template<class InputIterator>
priority_queue(InputIterator begin, InputIterator last)
{
//第一首先将数据插入进去
while (begin != last)
{
_con.push_back(*begin);
++begin;
}
//第二需要建堆，默认建的是大堆--利用向下调整算法建堆
//从最后一个叶子结点的父亲开始向下调整，然后依次往前走，直到走到堆顶。
for (int i = (_con.size() - 1 - 1) / 2; i >= 0; i--)
{
Adjustdown(i);
}
}
void Adjustup(int child)
{
Comapre com;
size_t parent = (child - 1) / 2;
while (child < _con.size())
{
//if (_con[child] > _con[parent])
if (com(_con[parent], _con[child]))
{
swap(_con[child], _con[parent]);
child = parent;
parent = (child - 1) / 2;
}
else
{
break;
}
}
}
void push(const T& x)
{
_con.push_back(x);
Adjustup(_con.size() - 1);
}
void pop()
{
swap(_con[0], _con[_con.size() - 1]);
_con.pop_back();
Adjustdown(0);
}
const T& top()
{
return _con[0];
}
bool empty()
{
return _con.empty();
}
size_t size()
{
return _con.size();
}
private:
Container _con;
};
} 四、反向迭代器
1、重新定义一个类
在 list 模拟实现的时候，只模拟实现了正向迭代器，反向迭代器还没有实现。接下来我们就可以来实现反向迭代器。之前我们是封装了一个类来实现正向迭代器，现在我们也同样封装一个反向迭代器的类。重新定义 rbegin() 和 rend().所以需要修改的是“++”和“--”的运算符重载。
【测验代码】
2、复用正向迭代器
⭕写一个反向迭代器固然可以实现目标的，但我们看 list 源代码时会发现他是对正向迭代器的复用。
⭕STL大佬在设计反向迭代器时，为了追求与正向迭代器的对称，将首尾指针得到指向反向保持一致，使
rbegin()在end()位置，rend()在begin()位置。⭕在这样的设计下，
rbegin()和rend()的实现就可以直接对应复用了，而operator*()返回的就不是当前所指向的对象，而是成了上一个对象。⭕前面在模拟实现
list时，运用了多参数模板来解决const对象代码冗余问题，在反向迭代器的实现中也运用了相同原理，通过对形参传递不同的对象，变换为不同的迭代器，其中Ref表示引用对象，Ptr表示指针对象。
3、完整代码
//反向迭代器模拟实现
namespace zhou
{
template<class Iterator, class Ref, class Ptr>
struct ReverseIterator
{
typedef ReverseIterator<Iterator, Ref, Ptr> Self;
Iterator _cur;
//用正向迭代器来构造反向迭代器
ReverseIterator(Iterator it)
:_cur(it)
{}
Ref operator*()
{
//为了对称返回前一个位置
Iterator tmp = _cur;
--tmp;
return *tmp;
}
Self& operator++()
{
--_cur;
return *this;
}
Self& operator--()
{
++_cur;
return *this;
}
bool operator!=(const Self& s)
{
return _cur != s._cur;
}
};
}
//完整 list 模拟实现
namespace zhou
{
template<class T>
struct list_node
{
list_node<T>* _next;
list_node<T>* _prev;
T _data;
list_node(const T& x = T())
:_next(nullptr)
, _prev(nullptr)
, _data(x)
{}
};
template<class T, class Ref, class Ptr>
struct __list_iterator
{
typedef list_node<T> node;
typedef __list_iterator<T, Ref, Ptr> self;
node* _node;
__list_iterator(node* n)
:_node(n)
{}
Ref operator*()
{
return _node->_data;
}
Ptr operator->()
{
return &_node->_data;
}
self& operator++()
{
_node = _node->_next;
return *this;
}
self operator++(int)
{
self tmp(*this);
_node = _node->_next;
return tmp;
}
self& operator--()
{
_node = _node->_prev;
return *this;
}
self operator--(int)
{
self tmp(*this);
_node = _node->_prev;
return tmp;
}
bool operator!=(const self& s)
{
return _node != s._node;
}
bool operator==(const self& s)
{
return _node == s._node;
}
};
//定义一个反向迭代器的类
/*template<class T, class Ref, class Ptr>
struct __list_reverse_iterator
{
typedef list_node<T> node;
typedef __list_reverse_iterator<T, Ref, Ptr> self;
node* _node;
__list_reverse_iterator(node* n)
:_node(n)
{}
Ref operator*()
{
return _node->_data;
}
Ptr operator->()
{
return &_node->_data;
}
self& operator++()
{
_node = _node->_prev;
return *this;
}
self operator++(int)
{
self tmp(*this);
_node = _node->_prev;
return tmp;
}
self& operator--()
{
_node = _node->_next;
return *this;
}
self operator--(int)
{
self tmp(*this);
_node = _node->_next;
return tmp;
}
bool operator!=(const self& s)
{
return _node != s._node;
}
bool operator==(const self& s)
{
return _node == s._node;
}
};*/
template<class T>
class list
{
typedef list_node<T> node;
public:
typedef __list_iterator<T, T&, T*> iterator;
typedef __list_iterator<T, const T&, const T*> const_iterator;
//typedef __list_reverse_iterator<T, T&, T*> reverse_iterator;
typedef ReverseIterator<iterator, T&, T*> reverse_iterator;
typedef ReverseIterator<iterator, const T&, const T*> const_reverse_iterator;
reverse_iterator rbegin()
{
return reverse_iterator(end());
}
reverse_iterator rend()
{
return reverse_iterator(begin());
}
/*reverse_iterator rbegin()
{
return reverse_iterator(_head->_prev);
}
reverse_iterator rend()
{
return reverse_iterator(_head);
}*/
iterator begin()
{
return iterator(_head->_next);
}
const_iterator begin() const
{
return const_iterator(_head->_next);
}
iterator end()
{
return iterator(_head);
}
const_iterator end() const
{
//iterator it(_head->_next);
//return it;
return const_iterator(_head);
}
void empty_init()
{
_head = new node;
_head->_next = _head;
_head->_prev = _head;
}
list()
{
empty_init();
}
template <class Iterator>
list(Iterator first, Iterator last)
{
empty_init();
while (first != last)
{
push_back(*first);
++first;
}
}
void swap(list<T>& tmp)
{
std::swap(_head, tmp._head);
}
list(const list<T>& lt)
{
empty_init();
list<T> tmp(lt.begin(), lt.end());
swap(tmp);
}
// lt1 = lt3
list<T>& operator=(list<T> lt)
{
swap(lt);
return *this;
}
~list()
{
clear();
delete _head;
_head = nullptr;
}
void clear()
{
iterator it = begin();
while (it != end())
{
//it = erase(it);
erase(it++);
}
}
void push_back(const T& x)
{
insert(end(), x);
}
void push_front(const T& x)
{
insert(begin(), x);
}
void pop_back()
{
erase(--end());
}
void pop_front()
{
erase(begin());
}
void insert(iterator pos, const T& x)
{
node* cur = pos._node;
node* prev = cur->_prev;
node* new_node = new node(x);
prev->_next = new_node;
new_node->_prev = prev;
new_node->_next = cur;
cur->_prev = new_node;
}
iterator erase(iterator pos)
{
assert(pos != end());
node* prev = pos._node->_prev;
node* next = pos._node->_next;
prev->_next = next;
next->_prev = prev;
delete pos._node;
return iterator(next);
}
private:
node* _head;
};
void list_list1()
{
list<int> lt;
lt.push_back(1);
lt.push_back(2);
lt.push_back(3);
lt.push_back(4);
lt.push_back(5);
for (auto e : lt)
{
cout << e << " ";
}
cout << endl;
list<int>::reverse_iterator rit = lt.rbegin();
while (rit != lt.rend())
{
cout << *rit << " ";
++rit;
}
}
}
