容器适配器queue，priority_queue的使用和模拟实现

queue是一种基于deque实现的容器适配器，具有先进先出的原则

queue的头文件#include <queue>

一.使用

1.size

2.empty

3.push

4.pop

5.front

6.back

int main()
{
	queue<int>Q;
	Q.push(1);
	Q.push(2);
	Q.push(3);
	Q.push(4);
	Q.push(5);
	Q.push(6);
	cout << Q.size() << endl;
	cout << Q.empty() << endl;
	cout << Q.back() << endl;
	cout << Q.front() << endl;
	Q.pop();
	cout << Q.back() << endl;
	cout << Q.front() << endl;
}

二.模拟实现

template<typename T,class Cont = deque<T>>
class Queue
{
public:
	explicit Queue()
	{}
	size_t size()const
	{
		return c.size();
	}
	bool empty()const
	{
		return c.empty();
	}
	T& front()
	{
		return c.front();
	}
	const T& front()const
	{
		return c.front();
	}
	T& back()
	{
		return c.back();
	}
	const T& back()const
	{
		return c.back();
	}
	void push(const T&value)
	{
		c.push_back(value);
	}
	void pop()
	{
		c.pop_front();
	}
protected:
	Cont c;
};
int main()
{
	Queue<int>Q;
	Q.push(1);
	Q.push(2);
	cout << Q.size() << endl;
	cout << Q.empty() << endl;
	cout << Q.back() << endl;
	cout << Q.front() << endl;
	Q.pop();
	return 0;
}

priority_queue：优先级队列，即它的第一个元素是队列里面最大的。其实优先级队列是一个堆，而且默认创建的是大堆。

priority_queue的底层是vector,和queue不一样，queue底层是deque

一.操作 ，因为都是队列，所以priority_queue和queue的操作差不多，不同的是priority_queue有top函数，而无front和back的概念，top函数获得的数即是队列里最大的元素。

int main()
{
	priority_queue<string>	Q1;
	Q1.push("abc");
	Q1.push("abcd00");
	Q1.push("h");
	Q1.push("fdgfdgklhi");
	cout << Q1.top() << endl;//输出h
	priority_queue<int>	Q2;
	Q2.push(7);
	Q2.push(5);
	Q2.push(99);
	Q2.push(0);
	cout << Q2.top() << endl;//输出99
	return 0;
}

二.模拟实现

用make_heap,push_heap,pop_heap进行模拟实现

namespace senpao
{
	template<class T>
	struct less
	{
		bool operator()(const T&left, const T&right)
		{
			return left < right;
		}
	};
	template<class T>
	struct greater
	{
		bool operator()(const T&left, const T&right)
		{
			return right>left;
		}
	};
	template<class T, class Cont = vector<T>, typename Pred = less<T>>
	class Priority_Queue
	{
	public:
		typedef     T    value_type;
		typedef size_t   size_type;
		explicit Priority_Queue() :c()
		{
			make_heap(c.begin(), c.end());
		}
		Priority_Queue(const value_type *first, const value_type *last) :c(first,last)
		{
			make_heap(c.begin(),c.end());
		}
		bool empty() const
		{
			return c.empty();
		}
		size_type size() const
		{
			return c.size();
		}
		value_type& top()
		{
			assert(!empty());
			return c.front();
		}
		const value_type& top() const
		{
			assert(!empty());
			return c.front();
		}
		void push(const value_type& x)
		{
			c.push_back(x);
			push_heap(c.begin(), c.end());
		}
		void pop()
		{
			c.pop_back();
			pop_heap(c.begin(), c.end());
		}
	protected:
		Cont c;
		Pred comp;
	};
};

自己实现堆排

namespace senpao
{
	template<class T>
	struct less
	{
		bool operator()(const T&left, const T&right)
		{
			return left < right;
		}
	};

	template<class T>
	struct greater
	{
		bool operator()(const T&left, const T&right)
		{
			return left> right;
		}
	};
	template<class T, class Cont = vector<T>, typename Pred = less<T>>
	class Priority_Queue
	{
	public:
		typedef     T    value_type;
		typedef size_t   size_type;
		explicit Priority_Queue()
		{

		}
		Priority_Queue(const value_type *first, const value_type *last)
		{
			while (first != last)
			{
				c.push_back(*first++);
				adjustup(c.size()-1);
			}
		}
		bool empty() const
		{
			return c.empty();
		}
		size_type size() const
		{
			return c.size();
		}
		value_type& top()
		{
			assert(!empty());
			return c.front();
		}
		const value_type& top() const
		{
			assert(!empty());
			return c.front();
		}
		void push(const value_type& x)
		{
			c.push_back(x);
			adjustup(c.size()-1);
		}
		void pop()
		{
			std::swap(c.front(),c.back());
			c.pop_back();
			adjustdown(0);
		}
		void adjustdown(int parent)
		{
			int child = parent * 2 + 1;
			while (child < c.size())
			{
				if ((child + 1 < c.size()) && comp(c[child],c[child+1]))
					child++;
				if (comp(c[parent], c[child]))
				{
					std::swap(c[parent], c[child]);
					parent = child;
					child = parent * 2 + 1;
				}
				else
					break;
			}
		}
		void adjustup(int child)
		{
			int parent = (child - 1) / 2;
			while (child)
			{
				if (comp(c[parent], c[child]))
				{
					std::swap(c[parent], c[child]);
					child = parent;
					parent = (child - 1) / 2;
				}
				else
					break;
			}
		}
	protected:
		Cont c;
		Pred comp;
	};
};