【C++】仿函数优先级队列反向迭代器

目录

一、优先级队列

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 = lt3list<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;}}
}