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