一文了解stack和queue類的實現

1. stack的介紹和使用

1.1 stack的介紹

1. stack是一種容器適配器，專門用在具有後進先出操作的上下文環境中，其刪除只能從容器的一端進行元素的插入與提取操作。
2. stack是作爲容器適配器被實現的，容器適配器即是對特定類封裝作爲其底層的容器，並提供一組特定的成員函數來訪問其元素，將特定類作爲其底層的，元素特定容器的尾部(即棧頂)被壓入和彈出。
3. stack的底層容器可以是任何標準的容器類模板或者一些其他特定的容器類，這些容器類應該支持以下操作：
   • empty：判空操作
   • back：獲取尾部元素操作
   • push_back：尾部插入元素操作
   • pop_back：尾部刪除元素操作
4. 標準容器vector、deque、list均符合這些需求，默認情況下，如果沒有爲stack指定特定的底層容器，默認情況下使用deque。
   

1.2 stack的使用

函數說明	接口說明
stack(const container_type& ctnr = container_type())	構造空的棧
bool empty() const	檢測stack是否爲空
size_type size() const	返回stack中元素的個數
value_type& top()	返回棧頂元素的引用
const value_type& top() const	返回棧頂元素的const引用
void push (const value_type& val)	將元素val壓入stack中
void pop()	將stack中尾部的元素彈出
template <class… Args> void emplace (Args&&… args)	(C++11) 在stack的棧頂構造元素
void swap (stack& x)	(C++11) 交換兩個棧中

2. queue的介紹和使用

2.1 queue的介紹

1. 隊列是一種容器適配器，專門用於在FIFO上下文(先進先出)中操作，其中從容器一端插入元素，另一端提取元素。
2. 隊列作爲容器適配器實現，容器適配器即將特定容器類封裝作爲其底層容器類，queue提供一組特定的成員函數來訪問其元素。元素從隊尾入隊列，從隊頭出隊列。
3. 底層容器可以是標準容器類模板之一，也可以是其他專門設計的容器類。該底層容器應至少支持以下操作:
   • empty：檢測隊列是否爲空
   • size：返回隊列中有效元素的個數
   • front：返回隊頭元素的引用
   • back：返回隊尾元素的引用
   • push_back：在隊列尾部入隊列
   • pop_front：在隊列頭部出隊列
4. 標準容器類deque和list滿足了這些要求。默認情況下，如果沒有爲queue實例化指定容器類，則使用標準容器deque。
   

2.2 queue的使用

函數聲明	接口說明
queue (const container_type& ctnr = container_type())	構造空的隊列
bool empty() const	檢測隊列是否爲空，是返回true，否則返回false
size_type size() const	返回隊列中有效元素的個數
value_type& front()	返回隊頭元素的引用
const value_type& front() const	返回隊頭元素的const引用
value_type& back()	返回隊尾元素的引用
const value_type& back() const	返回隊尾元素的cosnt引用
void push(value_type& val)	在隊尾將元素val入隊列
void pop()	將隊頭元素出隊列
template <class… Args> void emplace (Args&&… args)	(C++11) 在隊尾構造元素
void swap(queue& x)	交換兩個隊列中的元素

3 priority_queue的介紹和使用

3.1 priority_queue的介紹

1. 優先隊列是一種容器適配器，根據嚴格的弱排序標準，它的第一個元素總是它所包含的元素中最大的。
2. 此上下文類似於堆，在堆中可以隨時插入元素，並且只能檢索最大堆元素(優先隊列中位於頂部的元素)。
3. 優先隊列被實現爲容器適配器，容器適配器即將特定容器類封裝作爲其底層容器類，queue提供一組特定的成員函數來訪問其元素。元素從特定容器的“尾部”彈出，其稱爲優先隊列的頂部。
4. 底層容器可以是任何標準容器類模板，也可以是其他特定設計的容器類。容器應該可以通過隨機訪問迭代器訪問，並支持以下操作：
   • empty()：檢測容器是否爲空
   • size()：返回容器中有效元素個數
   • front()：返回容器中第一個元素的引用
   • push_back()：在容器尾部插入元素
   • pop_back()：刪除容器尾部元素
5. 標準容器類vector和deque滿足這些需求。默認情況下，如果沒有爲特定的priority_queue類實例化指定容器類，則使用vector。
6. 需要支持隨機訪問迭代器，以便始終在內部保持堆結構。容器適配器通過在需要時自動調用算法函數make_heap、push_heap和pop_heap來自動完成此操作。

3.2 priority_queue的使用

優先級隊列默認使用vector作爲其底層存儲數據的容器，在vector上又使用了堆算法將vector中元素構造成堆的結構，因此priority_queue就是堆，所有需要用到堆的位置，都可以考慮使用priority_queue。注意：默認情況下priority_queue是大堆。

函數聲明	接口說明
priority_queue(const Compare& x = Compare(), const Container& y = Container() );	構造一個空的優先級隊列
template priority_queue(InputIterator first, InputIterator last, const Compare& comp = Compare(), const Container& ctnr = Container());	用[first, last)區間中的元素構造優先級隊列
bool empty( ) const	檢測優先級隊列是否爲空，是返回true，否則返回false
const value_type& top ( ) const	返回優先級隊列中最大(最小元素)，即堆頂元素
void push ( const T& x )	在優先級隊列中插入元素x
void pop ( )	刪除優先級隊列中最大(最小)元素，即堆頂元素

1. 默認情況下，priority_queue是大堆。
2. 如果在priority_queue中放自定義類型的數據，用戶需要在自定義類型中提供> 或者< 的重載
3. 有些情況下，用戶可能需要提供比較器規則

4. 容器適配器

4.1 什麼是適配器

適配器是一種設計模式(設計模式是一套被反覆使用的、多數人知曉的、經過分類編目的、代碼設計經驗的總結)，該中模式是將一個類的接口轉換成客戶希望的另外一個接口。

4.2 爲什麼將stack、queue和priority_queue稱作爲容器適配器

雖然stack、queue、priority_queue中也可以存放元素，但在STL中並沒有將其劃分在容器的行列，而是將其稱爲容器適配器，這是因爲每個容器在底層都有自己的實現方式，而stack、queue、priority_queue只是在底層將其他容器進行了封裝，比如：

4.3 爲什麼選擇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不僅效率高，而且內
   存使用率高。

4.4模擬實現stack和queue

4.4.1 模擬實現stack

#include<iostream>
#include<deque>
using namespace std;
template<class T,class Con=deque<T>>
class Stack
{
public:
	Stack(){}
	void Push(const T& x){ _c.push_back(x); }
	void Pop(){ _c.pop_back(); }
	T& Top(){ return _c.back(); }
	const T& Top()const{ return _c.back(); }
	size_t Size()const{ return _c.size(); }
	bool Empty()const{ return _c.empty(); }
private:
	Con _c;
};
void TestStack()
{
	Stack<int> s;
	s.Push(1);
	s.Push(2);
	s.Push(3);
	s.Push(4);
	cout << s.Size() << endl;
	cout << s.Top() << endl;
	s.Pop();
	s.Pop();
	cout << s.Size() << endl;
	cout << s.Top() << endl;
	system("pause");
}
int main()
{
	TestStack();
	system("pause");
	return 0;
}

4.4.2 模擬實現queue

#include<iostream>
#include<deque>
using namespace std;
template<class T, class Con = deque<T>>
class Queue
{
public:
	Queue(){}
	void Push(const T& x){ _c.push_back(x); }
	void Pop(){ _c.pop_front(); }
	T& Back(){ return _c.back(); }
	const T& Back()const{ return _c.back(); }
	T& Front(){ return _c.front(); }
	const T& Front()const{ return _c.front(); }
	size_t Size()const{ return _c.size(); }
	bool Empty()const{ return _c.empty(); }
private:
	Con _c;
};
void TestQueue()
{
	// 適配體現在第二個模板參數可以使用不同的容器，然後適配生成的queue效果是一樣的。
	//Queue<int, deque<int>> q;
	//Queue<int, list<int>> q;

	Queue<int> q;
	q.Push(1);
	q.Push(2);
	q.Push(3);
	q.Push(4);
	cout << q.Size() << endl;
	cout << q.Front() << endl;
	cout << q.Back() << endl;

	q.Pop();
	q.Pop();
	cout << q.Size() << endl;
	cout << q.Front() << endl;
	cout << q.Back() << endl;
}
int main()
{
	TestQueue();
	system("pause");
	return 0;
}