vector

vector 是順序容器的一種，是可變長的動態數組，支持隨機訪問迭代器，所有stl算法都能對 vector 進行操作。
vector 容器在實現時，動態分配的存儲空間一般都大於存放元素所需的空間。例如，哪怕容器中只有一個元素，也會分配 32 個元素的存儲空間。這樣做的好處是，在尾部添加一個新元素時不必重新分配空間，直接將新元素寫入適當位置即可。在這種情況下，添加新元素的時間也是常數。但是，多出來的空間用完再添加新元素，就不得不重新分配內存空間，把原有內容複製過去後再添加新的元素。

vector中常用的成員函數
成員函數	作用
vector()	無參構造函數，將容器初始化爲空
vector(int n)	將容器初始化爲有 n 個元素
vector(int n, const T & val)	假定元素的類型是 T，此構造函數將容器初始化爲有 n 個元素，每個元素的值都是 val
vector(iterator first, iterator last)	first 和 last 可以是其他容器的迭代器。一般來說，本構造函數初始化的結果就是將 vector 容器的內容變成與其他容器上的區間 [first, last) —致
void clear()	刪除所有元素
bool empty()	判斷容器是否爲空
void pop_back()	刪除容器末尾的元素
void push_back( const T & val)	將 val 添加到容器末尾
int size()	返回容器中元素的個數
T & front()	返回容器中第一個元素的引用
T & back()	返回容器中最後一個元素的引用
iterator insert(iterator i, const T & val)	將 val 插入迭代器 i 指向的位置，返回 i
iterator insert( iterator i, iterator first, iterator last)	將其他容器上的區間 [first, last) 中的元素插入迭代器 i 指向的位置
iterator erase(iterator i)	刪除迭代器 i 指向的元素，返回值是被刪元素後面的元素的迭代器
iterator erase(iterator first, iterator last)	刪除容器中的區間 [first, last)
void swap( vector <T> & v)	將容器自身的內容和另一個同類型的容器 v 互換

#include <iostream>
#include <vector>  //使用vector需要包含此頭文件
using namespace std;
template <class T>
void PrintVector(const vector <T> & v)
{  //用於輸出vector容器的全部元素的函數模板
    typename vector <T>::const_iterator i;
    //typename 用來說明 vector <T>::const_iterator 是一個類型，在 Visual Studio 中不寫也可以
    for (i = v.begin(); i != v.end(); ++i)
        cout << *i << " ";
    cout << endl;
}
int main()
{
    int a[5] = { 1, 2, 3, 4, 5 };
    vector <int> v(a, a + 5);  //將數組a的內容放入v
    cout << "1) " << v.end() - v.begin() << endl;  //兩個隨機迭代器可以相減，輸出：1)5
    cout << "2)"; PrintVector(v);  //輸出：2)1 2 3 4 5
    v.insert(v.begin() + 2, 13);  //在 begin()+2 位置插人 13
    cout << "3)"; PrintVector(v);  //輸出：3)1 2 13 3 4 5
    v.erase(v.begin() + 2);  //刪除位於 begin()+2 位置的元素
    cout << "4)"; PrintVector(v);  //輸出：4)1 2 3 4 5
    vector<int> v2(4, 100);  //v2 有 4 個元素，都是 100
    v2.insert(v2.begin(), v.begin() + 1, v.begin() + 3);  //將v的一段插入v2開頭
    cout << "5)v2:"; PrintVector(v2);  //輸出：5)v2:2 3 100 100 100 100
    v.erase(v.begin() + 1, v.begin() + 3);  //刪除 v 上的一個區間，即 [2,3)
    cout << "6)"; PrintVector(v);  //輸出：6)1 4 5
    return 0;
}

#include <iostream>
#include <vector>
using namespace std;
int main()
{   
    vector<vector<int> > v(3); //v有3個元素，每個元素都是vector<int> 容器
    for(int i = 0;i < v.size(); ++i)
        for(int j = 0; j < 4; ++j)
            v[i].push_back(j);
    for(int i = 0;i < v.size(); ++i) {
        for(int j = 0; j < v[i].size(); ++j)
            cout << v[i][j] << " ";
        cout << endl;
    }
    return 0;
}

list

list 是順序容器的一種。list 是一個雙向鏈表。使用 list 需要包含頭文件 list。雙向鏈表的每個元素中都有一個指針指向後一個元素，也有一個指針指向前一個元素。

list 容器不支持根據下標隨機存取元素。

list 的構造函數和許多成員函數的用法都與 vector 類似，此處不再列舉。除了順序容器都有的成員函數外，list 還獨有如下函數

成員函數或成員函數模板	作用
void push_front(const T & val)	將 val 插入鏈表最前面
void pop_front()	刪除鏈表最前面的元素
void sort()	將鏈表從小到大排序
void remove (const T & val)	刪除和 val 相等的元素
remove_if	刪除符合某種條件的元素
void unique()	刪除所有和前一個元素相等的元素
void merge(list <T> & x)	將鏈表 x 合並進來並清空 x。要求鏈表自身和 x 都是有序的
void splice(iterator i, list <T> & x, iterator first, iterator last)	在位置 i 前面插入鏈表 x 中的區間 [first, last)，並在鏈表 x 中刪除該區間。鏈表自身和鏈表 x 可以是同一個鏈表，只要 i 不在 [first, last) 中即可

STL 中的算法 sort 可以用來對 vector 和 deque 排序，它需要隨機訪問迭代器的支持。因爲 list 不支持隨機訪問迭代器，所以不能用算法 sort 對 list 容器排序。因此，list 容器引入了 sort 成員函數以完成排序。

#include <list>  //使用 list 需要包含此頭文件
#include <iostream>
#include <algorithm>  //使用STL中的算法需要包含此頭文件
using namespace std;
class A {
private: int n;
public:
    A(int n_) { n = n_; }
    friend bool operator < (const A & a1, const A & a2);
    friend bool operator == (const A & a1, const A & a2);
    friend ostream & operator << (ostream & o, const A & a);
};
bool operator < (const A & a1, const A & a2) {
    return a1.n < a2.n;
}
bool operator == (const A & a1, const A & a2) {
    return a1.n == a2.n;
}
ostream & operator << (ostream & o, const A & a) {
    o << a.n;
    return o;
}
template <class T>
void Print(T first, T last)
{
    for (; first != last; ++first)
        cout << *first << " ";
    cout << endl;
}
int main()
{
    A a[5] = { 1, 3, 2, 4, 2 };
    A b[7] = { 10, 30, 20, 30, 30, 40, 40 };
    list<A> lst1(a, a + 5), lst2(b, b + 7);
    lst1.sort();
    cout << "1)"; Print(lst1.begin(), lst1.end());  //輸出：1)1 2 2 3 4
    lst1.remove(2);  //刪除所有和A(2)相等的元素
    cout << "2)"; Print(lst1.begin(), lst1.end());  //輸出：2)1 3 4
    lst2.pop_front();  //刪除第一個元素
    cout << "3)"; Print(lst2.begin(), lst2.end());  //輸出：3)30 20 30 30 40 40
    lst2.unique();  //刪除所有和前一個元素相等的元素
    cout << "4)"; Print(lst2.begin(), lst2.end());  //輸出：4)30 20 30 40
    lst2.sort();
    lst1.merge(lst2);  //合併 lst2 到 lst1 並清空 lst2
    cout << "5)"; Print(lst1.begin(), lst1.end());  //輸出：5)1 3 4 20 30 30 40
    cout << "6)"; Print(lst2.begin(), lst2.end());  //lst2是空的，輸出：6)
    lst1.reverse();  //將 lst1 前後顛倒

    cout << "7)"; Print(lst1.begin(), lst1.end());  //輸出 7)40 30 30 20 4 3 1
    lst2.insert(lst2.begin(), a + 1, a + 4);  //在 lst2 中插入 3,2,4 三個元素
    list <A>::iterator p1, p2, p3;
    p1 = find(lst1.begin(), lst1.end(), 30);
    p2 = find(lst2.begin(), lst2.end(), 2);
    p3 = find(lst2.begin(), lst2.end(), 4);
    lst1.splice(p1, lst2, p2, p3);  //將[p2, p3)插入p1之前，並從 lst2 中刪除[p2,p3)
    cout << "8)"; Print(lst1.begin(), lst1.end());  //輸出：8)40 2 30 30 20 4 3 1
    cout << "9)"; Print(lst2.begin(), lst2.end());  //輸出：9)3 4
    return 0;
}

棧

stack 是容器適配器的一種。要使用 stack，必須包含頭文件 <stack>。
stack就是“棧”。是一種後進先出的元素序列，訪問、添加和刪除都只能對棧頂的元素行。棧內的元素不能訪問。
stack的定義如下：

template < class T, class Cont == deque <T> >
class stack{
    ...
};

第二個參數表明，在默認情況下，stack 就是用 deque 實現的。當然，也可以指定用 vector 或 list 實現。

雖然 stack 使用順序容器實現，但它不提供順序容器具有的成員函數。除了 size、 empty 這兩個所有容器都有的成員函數外，stack 還有以下三個成員函數

stack的成員函數
成員函數	功能
void pop();	彈出（即刪除）棧頂元素
T & top();	返回棧頂元素的引用。通過此函數可以讀取棧頂元素的值，也可以修改棧頂元素
void push (const T & x);	將 x 壓入棧頂

#include <iostream>
#include <stack>  //使用stack需要包含此頭文件
using namespace std;
int main()
{
    int n, k;
    stack <int> stk;
    cin >> n >> k;  //將n轉換爲k進制數
    if (n == 0) {
        cout << 0;
        return 0;
    }
    while (n) {
        stk.push(n%k);
        n /= k;
    }
    while (!stk.empty()) {
        cout << stk.top();
        stk.pop();
    }
    return 0;
}

queue

queue 就是“隊列”。隊列是先進先出的。隊頭的訪問和刪除操作只能在隊頭進行，添加操作只能在隊尾進行。不能訪問隊列中間的元素。

queue 可以用 list 和 deque 實現，默認情況下用 deque 實現。
queue 的定義如下：

template < class T, class Cont = deque<T> >
class queue{
    ...
};

queue 同樣也有和 stack 類似的 push、pop、top 函數。區別在於，queue 的 push 發生在隊尾，pop 和 top 發生在隊頭。

priority_queue

priority_queue 是“優先隊列”。它和普通隊列的區別在於，優先隊列的隊頭元素總是最大的——即執行 pop 操作時，刪除的總是最大的元素；執行 top 操作時，返回的是最大元素的引用。

priority_queue 可以用 vector 和 deque 實現，默認情況下用 vector 實現。

priority_queue 默認的元素比較器是 less <T>。也就是說，在默認情況下，要放入 priority_queue 的元素必須是能用“<”運算符進行比較的，而且 priority _queue 保證以下條件總是成立：對於隊頭的元素 x 和任意非隊頭的元素 y，表達式“x<y”必爲 false。

priority_queue 定義如下：

template < class T, class Container = vector <T>, class Compare = less<T> >
class priority_queue{
    ...
};

priority_queue 的第三個類型參數可以用來指定排序規則。

priority_queue 是使用“堆排序”技術實現的，其內部並非完全有序，但卻能確保最大元素總在隊頭。因此，priority_queue 特別適用於“不停地在一堆元素中取走最大的元素”這種情況。

C++ STL 線性容器的用法

vector

list

棧

queue

priority_queue

爲什麼要⽤ Foundry

【筆記】動手學深度學習-預備知識

py發送email

MySQL 分庫分表方案，總結太全了。。

Qt/C++音視頻開發71-指定mjpeg/h264格式採集本地攝像頭/存儲文件到mp4/設備推流/採集推流

WPF開源輕便、快速的桌面啓動器

公司來了個新同事，把 DDD 運用得爐火純青！

leetcode700. 二叉搜索樹中的搜索

leetcode645. 錯誤的集合

leetcode485. 最大連續1的個數 *py：“又是一行就解決了，沒意思”

【大總結2】大學兩年，寫了這篇幾十萬字的乾貨總結

【大總結3】leetcode解題總覽（算法、劍指offer、SQL、多線程、shell）

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結