目录
一、优先级队列
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;}}
}