stack、queue、priority_queue的模拟实现

stack的模拟实现：

#pragma once
#include<iostream>
#include<vector>
using namespace std;
template<class T, class Container = vector<T>>
class Stack
{
public:
	Stack()
	{}
	void Push(const T& x)
	{
		_con.push_back(x);
	}
	void Pop()
	{
		_con.pop_back();
	}
	
	const T& Top()
	{
		return _con.back();
	}
	size_t Size()const
	{
		return _con.size();
	}
	bool Empty()const
	{
		return _con.empty();
	}
private:
	Container _con;
};
void TestStack()
{
	Stack<int> s;
	s.Push(1);
	s.Push(2);
	s.Push(3);
	s.Push(4);
	s.Push(5);
	s.Push(6);
	cout << s.Size() << endl;
	cout << s.Top() << endl;
	while (!s.Empty())
	{
		cout << s.Top() << " ";
		s.Pop();
	}
	cout << endl;
}

queue的模拟实现：

#pragma once
#include<iostream>
#include<list>
#include<deque>
using namespace std;
template<class T, class Container = deque<T>>
class Queue
{
public:
	void Push(const T& x)
	{
		_con.push_back(x);
	}
	void Pop()
	{
		_con.pop_front();
	}
	const T& Back()
	{
		return _con.back();
	}
	const T& Front()
	{
		return _con.front();
	}
	size_t Size()const
	{
		return _con.size();
	}
	bool Empty()const
	{
		return _con.empty();
	}
private:
	Container _con;
};
void TestQueue()
{
	Queue<int, deque<int>> q1;
	Queue<int> q;
	q.Push(1);
	q.Push(2);
	q.Push(3);
	cout << q.Size() << endl;
	cout << q.Front() << endl;
}

priority_queue的模拟实现：

#pragma once
#include<vector>
template<class T, class Container = vector<T>, class Compare = less<T>>
class PriorityQueue
{
public:
     //建大堆
	void AdjustUp(size_t child)
	{
		size_t parent = (child - 1) >> 1;
		while (child > 0)
		{
			Compare com;
			if (com(_con[parent] , _con[child]))
			{
				swap(_con[parent], _con[child]);
				child = parent;
				parent = (child - 1) >> 1;
			}
			else
			{
				break;
			}
		}
	}
//建大堆
	void AdjustDown(size_t parent)
	{
		size_t child = parent * 2 + 1;
		while (child < _con.size())
		{
			Compare com;
			if (child + 1 < _con.size() && com(_con[child], _con[child + 1]))
			{
				++child;
			}
			if (com(_con[parent], _con[child]))
			{
				swap(_con[parent], _con[child]);
				parent = child;
				child = parent * 2 + 1;
			}
			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];
	}
	size_t Size()
	{
		return _con.size();
	}
	bool Empty()
	{
		return _con.empty();
	}
private:
	Container _con;
};
void TestPriorityQueue()
{
	PriorityQueue<int, vector<int>, less<int>> pq;
	pq.Push(5);
	pq.Push(6);
	pq.Push(1);
	pq.Push(2);
	pq.Push(9);
	pq.Push(10);

	while (!pq.Empty())
	{
		cout << pq.Top() << " ";
		pq.Pop();
	}
	cout << endl;
}

为什么选择deque作为stack和queue的底层默认容器

stack是一种后进先出的特殊线性数据结构，因此只要具有push_back()和pop_back()操作的线性结构，都可以作为stack的底层容器，比如vector和list都可以；queue是先进先出的特殊线性数据结构，只要具有 push_back和pop_front操作的线性结构，都可以作为queue的底层容器，比如list。但是STL中对stack和 queue默认选择deque作为其底层容器，主要是因为：
1. stack和queue不需要遍历(因此stack和queue没有迭代器)，只需要在固定的一端或者两端进行操作。

2. 在stack中元素增长时，deque比vector的效率高；queue中的元素增长时，deque不仅效率高，而且内 存使用率高。