c++---stack和queue

1. stack的介紹和使用
2. queue的介紹和使用
3. priority_queue的介紹和使用
4. 容器適配器

一，stack的介紹和使用
介紹

• stack是一種容器適配器，專門用在具有後進先出操作的上下文環境中，其刪除只能從容器的一端進行 元素的插入與提取操作。
• stack是作爲容器適配器被實現的，容器適配器即是對特定類封裝作爲其底層的容器，並提供一組特定 的成員函數來訪問其元素，將特定類作爲其底層的，元素特定容器的尾部(即棧頂)被壓入和彈出。
• stack的底層容器可以是任何標準的容器類模板或者一些其他特定的容器類，這些容器類應該支持以下操作：

    empty：判空操作 
    back：獲取尾部元素操作
    push_back：尾部插入元素操作 
    pop_back：尾部刪除元素操作 

• 標準容器vector、deque、list均符合這些需求，默認情況下，如果沒有爲stack指定特定的底層容器， 默認情況下使用deque。
  
  使用

stack()；//構造空的棧
empty();//檢測stack是否爲空
size();//返回stack中元素的個數
top();//返回棧頂元素的引用
push();//將元素val壓入stack中
pop();//將stack中尾部的元素彈出

例如：
最小棧的實現

#include <iostream>
#include <stack>
using std::endl;
using std::cout;
class MinStack {
public:
	/** initialize your data structure here. */
	MinStack() {

	}

	void push(int x) {
		_elem.push(x);
		if (_min.empty() || x <= _min.top()){
			_min.push(x);
		}
	}

	void pop() {
		if (_min.top() == _elem.top()){
			_min.pop();
		}
		_elem.pop();
	}

	int top() {
		return _elem.top();
	}

	int getMin() {
		return _min.top();
	}
private:
	std::stack<int>_elem;
	std::stack<int>_min;
};
int main(){
	MinStack s;
	s.push(2);
	s.push(1);
	cout << s.getMin() << endl;
	system("pause");
	return EXIT_SUCCESS;
}

逆波蘭表達式

#include <iostream>
#include <vector>
#include <stack>
#include <string>
using namespace std;
class Solution {
public:
	int evalRPN(vector<string>& tokens) {
		for (int i = 0; i < tokens.size(); i++){
			if (tokens[i] == "-" || tokens[i] == "+" || tokens[i] == "*" || tokens[i] == "/"){
				int num1 = _num.top();
				_num.pop();
				int num2 = _num.top();
				_num.pop();
				int ret = 0;
				if (tokens[i] == "+"){
					ret = num2 + num1;
				}
				if (tokens[i] == "-"){
					ret = num2 - num1;
				}
				if (tokens[i] == "/"){
					ret = num2 / num1;
				}
				if (tokens[i] == "*"){
					ret = num1*num2;
				}
				_num.push(ret);
			}
			else{
				int num = atoi(tokens[i].c_str());
				_num.push(num);
			}
		}
		return _num.top();
	}
private:
	stack<int> _num;
};
int main(){

	Solution s;
	vector<string>v;
	v.push_back("2");
	v.push_back("1");
	v.push_back("+");
	v.push_back("3");
	v.push_back("*");
	cout << s.evalRPN(v) << endl;;
	system("pause");
	return EXIT_SUCCESS;
}

二，queue的介紹和使用
介紹

1. 隊列是一種容器適配器，專門用於在FIFO上下文(先進先出)中操作，其中從容器一端插入元素，另一端 提取元素。
2. 隊列作爲容器適配器實現，容器適配器即將特定容器類封裝作爲其底層容器類，queue提供一組特定的 成員函數來訪問其元素。元素從隊尾入隊列，從隊頭出隊列。
3. 底層容器可以是標準容器類模板之一，也可以是其他專門設計的容器類。該底層容器應至少支持以下操 作:

• empty();//檢測隊列是否爲空
• size();//返回隊列中有效元素的個數
• front();//返回隊頭元素的引用
• back();//返回隊尾元素的引用
• push_back();//再隊列尾部入數據
• pop_front();//再隊列頭部出數據

4. 標準容器類deque和list滿足了這些要求。默認情況下，如果沒有爲queue實例化指定容器類，則使用標 準容器deque。
   
   使用

queue() ；//構造空的隊列
empty() ；//檢測隊列是否爲空，是返回true，否則返回false
size() ；//返回隊列中有效元素的個數
front() ；//返回隊頭元素的引用
back() ；//返回隊尾元素的引用
push()；// 在隊尾將元素val入隊列
pop()；//將隊頭元素移除隊列

例子：二叉樹的層序遍歷

public List<List<Integer>> levelOrder(TreeNode root) {
    if(root == null)
        return new ArrayList<>();
    List<List<Integer>> res = new ArrayList<>();
    Queue<TreeNode> queue = new LinkedList<TreeNode>();
    queue.add(root);
    while(!queue.isEmpty()){
        int count = queue.size();
        List<Integer> list = new ArrayList<Integer>();
        while(count > 0){
            TreeNode node = queue.poll();
            list.add(node.val);
            if(node.left != null)
                queue.add(node.left);
            if(node.right != null)
                queue.add(node.right);
            count--;
        }
        res.add(list);
    }
    return res;
}

三，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來自動完成此操作。
   priority_queue其實就是一個堆，其實主要就是兩個算法，一個是堆的向上推演，一個是堆的向下推演。
   例如我們push_heap();
   
   pop_heap()
   

使用：

priority_queue()/priority_queue(first, last)；//構造一個空的優先級隊列
empty( )；//檢測優先級隊列是否爲空，是返回true，否則返回 false
top( ) ；//返回優先級隊列中最大(最小元素)，即堆頂元素
push(x) ；//在優先級隊列中插入元素x
pop() ；//刪除優先級隊列中最大(最小)元素，即堆頂元素

注意：再priority_queue是一個大堆

void TestPriorityQueue() {    
	// 默認情況下，創建的是大堆，其底層按照小於號比較    
	vector<int> v{3,2,7,6,0,4,1,9,8,5};    
	priority_queue<int> q1;    
	for (auto& e : v)        
		q1.push(e);    
	cout << q1.top() << endl;

	// 如果要創建小堆，將第三個模板參數換成greater比較方式    
	priority_queue<int, vector<int>, greater<int>> q2(v.begin(), v.end());    
	cout << q2.top() << endl;
}

這裏我們需要認識一種適配器，因爲再優先級隊列中我們可以使用vector，list，等來實現，這時候需要我們指定需要使用的容器。
這裏見我們的設計模式之適配器模式
爲什麼要將stack和queue，priority_queue稱爲容器設配器。
雖然stack，queue，priority_queue中也可以存放元素，到那時再STL中並沒有將其劃分再容器之內，二十將其稱爲容器適配器，這是因爲每個容器再底層都有自己的實現方式，但是stack，queue，priority_queue只是再底層將其他的容器進行了封裝。

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

使用例子：數組中的第k個最大元素

class Solution {
public:  
	int findKthLargest(vector<int>& nums, int k) {  
			   // 將數組中的元素先放入優先級隊列中    
		priority_queue<int> p(nums.begin(), nums.end());     
			   // 將優先級隊列中前k-1個元素刪除掉      
		for(int i= 0; i < k-1; ++i) {         
			p.pop();	
		}            
		return p.top();   
	} 
};