1.vector

#include <iostream>
#include <vector>

using namespace std;

int main(){
    vector<int> v = {1,2,3,4}; //可变长度数组，只支持尾部插入
    cout<<v.size()<<v.empty()<<endl;
    v.clear();

    //通过迭代器访问 vector 中的元素(迭代器类似指针)
    for(vector<int>::iterator it = v.begin();it!=v.end();it++){
        //begin函数返回第一个元素的指针，end函数返回最后一个元素之后的指针

        *it = *it * 2; // 通过迭代器修改元素
        cout << *it << " "; // 通过迭代访问
    }
    //数组形式访问 vector 中的元素
    for (int i = 0; i < v.size(); i ++){
        v[i] = v[i]*2;
        cout << v[i] << endl;
    }
   /*
    *it.begin() = v[0] = v.front()
    *(--it.end()) = v[v.size()-1] = v.back()
    */


    v.push_back(6);
    v.pop_back();


    return 0;
}

2.queue

#include <iostream>
#include <queue>

using namespace std;

int main(){
    queue<int> q; // 先进先出
    q.push(1); 
    q.push(2);
    q.push(3);
    q.pop(); 
    cout << "Front: " << q.front() << endl;  // 输出 2
    cout << "Back: " << q.back() << endl;    // 输出 3

    priority_queue<int> pq;   // 任意顺序插入;访问或删除时按照优先级（默认大根堆
    pq.push(1); 
    pq.push(3); 
    pq.push(2); 
    pq.pop();  
    cout << "Top: " << pq.top() << endl;  // 输出 2


    priority_queue<int, vector<int>, greater<int>> pq;   // 小根堆
    priority_queue<pair<int, int>> p; //按照字典顺序比较

    // 插入几个pair
    p.push({1, 5});
    p.push({2, 3});
    p.push({1, 6});
    p.push({2, 2});

    // 按字典顺序输出并移除元素
    while (!p.empty()) {
        pair<int, int> q = p.top();
        cout << "(" << q.first << ", " << q.second << ") ";
        p.pop();
    }
    return 0;
}

3.stack

#include <iostream>
#include <stack>

using namespace std;

int main() {

    stack<int> s; //先进后出
    // 向栈中推入元素
    s.push(1);
    s.push(2);
    s.push(3);

    // 输出并弹出栈顶元素
    while (!s.empty()) {
        cout << s.top() << endl;  // 输出栈顶元素
        s.pop();  // 弹出栈顶元素
        // 区别“输出”和“弹出”
    }

    return 0;
}

4.deque

#include <iostream>
#include <deque>

using namespace std;

int main() {
    deque<int> d;
 /*
    类似于vector和queue的结合
    1.可以在队列的头部和尾部插入或删除元素，时间复杂度均为 O(1)
    2.支持随机访问数组元素
*/

/*

front()：返回队列头部的元素。
back()：返回队列尾部的元素。
operator[]：随机访问队列中的元素。
size()：返回队列中的元素数量。
empty()：检查队列是否为空。
*/

    // 在队列尾部插入元素
    d.push_back(3);
    d.push_back(4);
    // 在队列头部插入元素
    d.push_front(2);
    d.push_front(1)

    // 移除队列头部和尾部元素
    d.pop_front();
    d.pop_back();

    // 随机访问队列的内容
    for (int i = 0; i < d.size(); i++) {
        cout << d[i] << endl;  // 2 3
    }
    // 迭代器顺序访问
    for(deque<int>::iterator it = d.begin();it!=d.end();it++){
         cout << *it << endl; 
    }


    // 输出头/尾的元素
    cout << "Front element: " << d.front() << endl;  // 2
    cout << "Back element: " << d.back() << endl;    // 3


    d.clear();
    return 0;
}

5.set

#include <iostream>
#include <set>

using namespace std;

int main(){

    set<int> s1;  // 升序集合
    set<int, greater<int>> s2; // 降序集合 
    multiset<double> m;  // 有序多重集合

    // 插入元素,时间复杂度为O(logn)
    s1.insert(1);
    s1.insert(2);
    s1.insert(1);  // 重复插入的元素会被忽略
    s1.insert(3);

    // 迭代器顺序（默认降序）访问元素
    for (set<int>::iterator it = s1.begin(); it != s1.end(); ++it) {
        cout << *it << endl;  // 输出 1 2 3
    }
    for(set<int>::iterator rit = (--s1.end());rit!=s1.begin(); rit--){

    }

     // 查找元素。成功则返回该元素的迭代器,否则返回end()
    if (s1.find(10) != s1.end()) {
        std::cout << "Element 10 is found in the set." << std::endl;
    }else{
        std::cout << "Element 10 is not found in the set after deletion." << std::endl;
    }

    //查找元素
    /*
    lower_bound(x)查找大于等于x的元素中最小的一个，并返回指向该元素的迭代器。
    upper_bound(x)查找大于x的元素中最小的一个，并返回指向该元素的迭代器。
    */
   if (s1.lower_bound(2) != s1.end()) 
   if (s1.upper_bound(1) != s1.end()) 


    // 删除元素
    /*设it是一个迭代器，s.erase(it)从s中删除迭代器it指向的元素，时间复杂度为 𝑂(𝑙𝑜𝑔𝑛)。
      设x是一个元素，s.erase(x)从s中删除所有等于x的元素，时间复杂度为 O(k+logn),其中 k是被删除的元素个数。*/
    s1.erase(1);

    //元素个数
    /*s.count(x)返回集合s中等于x的元素个数，时间复杂度为 O(k+logn),其中 k为元素x的个数。*/
    s1.count(2);

    return 0;
}

6.map

#include <iostream>
#include <map>

using namespace std;
int main() {
   /*
    map容器是一个键值对key-value的映射
    map<key_type, value_type> name;
    */
    map<int, string> m;

    // 插入元素方法1
    m[1] = "Apple";
    m[2] = "Banana";
    m[3] = "Cherry";
    // 插入元素方法2
    m.insert({4, "Date"}); // 参数是pair<key_type, value_type>

     // 删除元素
     /*
        按键删除：erase(const Key& key) 根据键值删除元素，返回删除的元素数量。
        按迭代器删除：erase(iterator pos) 删除指定位置的元素，返回下一个元素的迭代器。
        按迭代器范围删除：erase(iterator first, iterator last) 删除 [first, last) 范围内的元素，返回指向 last 的迭代器。
    */


    // 使用迭代器遍历 map
    for (map<int, std::string>::iterator it = m.begin(); it != m.end(); ++it) {
        cout << "Key: " << it->first << ", Value: " << it->second << endl;
    }
    // 遍历map
    for (auto pair : m) { // pair是拷贝的副本
        cout << "Key: " << pair.first << ", Value: " << pair.second << endl;
    }

    // 查找键对应的值
    auto it = m.find(2);
    if (it != m.end()) {
        cout << "Key 2: " << it->second << std::endl;  // 输出 Banana
    } else {
        cout << "Key 2 not found." << std::endl;
    }


    return 0;
}

反向迭代器（vector\deque\set\map）

for (vector<int>::reverse_iterator rit = v.rbegin(); rit != v.rend(); ++rit) {
        cout << *rit << endl;
    }

7.tuple

tuple 中获取某个位置的元素

C++ 提供了 get<index>(tuple) 这种用法，其中 index 是 tuple 中元素的下标（从 0 开始）。