1. 数据结构

1.1. list

#include <list>
List<int> mylist;
list<string> names= {"a","b","c"};
list<int> list(my_list.begin(), mylist.end());
list<int> tenZeros(10);// 初始化十个数，默认为0
list<int> tenSeverns(10,7); // 初始化十个7

1.1.1. 添加元素

mylist.push_back(10);

mylist.push_front(10);

// 在这个迭代器之前插入元素
auto it = mylist.begin();
mylist.insert(it+1, 15);

// 在这个迭代器后插入一串元素
mylist.insert(it, vec.begin() ,vec.end());

1.1.2. 访问

mylist.enpty()
mylist.front()
mylist.back()

1.1.3. 删除元素

mylist.pop_front(); //有返回吗
mylist.pop_back();
auto it = mylist.begin();
it = mylist.erase(it);

mylist.erase(mylist.begin()+1, mylist.end());

1.1.4. 遍历

for(auto it = mylist.begin(); it != mylist.end90 ;it++){
    (*it) ++; 
}

for(auto num : mylist){
    num++;
}

for(auto& num :mylist){
    num ++; //修改值时使用引用   
}

1.1.5. 合并

mylist.sort(); // 默认从小到大排序
mylist.sort([](int a, int b){
    return a>b;
});//a>b 从大到小排序

// 合并 ,要求list1, list2都需要排序
list1.merge(list2)

1.1.6. 唯一化

mylist.unique();

// 自定义相等
mylist.unique([](int a, int b){
    return abs(a-b)<2;
});

// 反转 
revList.reverse();

1.1.7. 拼接

std::list<int> listA = {1, 2};
std::list<int> listB = {3, 4, 5};
listA.splice(listA.end(), listB); // listA: {1, 2, 3, 4, 5}, listB: {}
listX.splice(listX.end(), listY, it_y); // listX: {10, 20, 30}, listY: {40, 50}
listP.splice(listP.end(), listQ, first_q, last_q);

1.2. vector

#include <vector>
vector<int> myv;

// 从数组中创建vector
arr = {1,2,3,4};
myv = vector<int> (arr, arr+ sizeof(arr)/ sizeof(arr[0]));

1.2.1. 插入数据

myv.push_back(value);

myv.emplace_back(value1, value2);// value1 ,value2 可以组成结构体数据

1.2.2. 访问元素

myv[0] ;

try{
    myv.at(0);
    // 对数据边界检测，返回Out_of_range 异常
}catch {const out_of_range& e}{
    cerr<< e.what()<<endl;
}

auto it = myv.front(); // 返回引用，指针？值引用？
auto it = myv.back();


int* data= myv.data();// 返回数据数组指针

1.2.3. 排序

#include <algorithm>
sort(my.begin() , my.end());// 从小到大排序

sort(my.begin(), my.end(), [](int a, int b){
    return a>b;  
});


sort(my.begin(), my.end(), greater<int>());// 从大到小排序

1.2.4. 合并

vector<int> merge(v1.size() + v2.size());

// v1，v2完成排序，合并结果在merge中
merger(v1.begin, v1.end() ,v2.begin(), v2.end(), merge.begin());

1.3. stack and queue

#include <stack>
stack<int> mys = stack<int, vector<int>> (vec); // 指定底层容器有什么效果


mys.push();
mys.top();
mys.pop();
mys.size();
mys.empty();

#include <queue>
queue<int> myq ;
queue<int, list<int>> myq(vec);

myq.push();
myq.front(); // 对头使用front, 栈顶使用top
myq.back(); 

1.4. deque

使用方法与vector类似，存储使用块与链表链接，比vector的性能好

1.5. map

数据有序排列

#include <map>
map<string, age> mymap ={{"a",20}};

mymap["b"]=20;
auto [it, inserted] = mymap.insert{{"c",10}};
mymap.emplace("c",10);
// 如果插入已存在，inserted值为false

1.5.1. 访问

mymap["a"]; // 没有自动创建元素
mymap.at["b"];// 没有抛出异常out_of_range


auto it = mymap.find(key);
if(it != mymap.end()){
    return 0;
}
// 对键进行计数，map默认最多有1个键值
if(mymap.count(key)){
    
}

for(auto& pair: mymap){
    pair.first; // key是第一个元素
    pair.second; //value是第二个元素
}

1.5.2. unordered_map

#include <unordered_map>

使用Hash表映射

1.5.3. multimap

multimap<string, int> mymap;

// 不可以使用[], at()

//find()， 返回一个迭代器
//equal_range(key), 返回一个pair, 包含两个迭代器，表示所有具有该键的元素的范围（[first, last)）

1.5.4. unordered_multimap

使用方法与multimap相同

1.6. pair

#include <utility>

1.7. set

#include <set>
set<int, [](int a, int b){
    return a>b}> set1 = {1,2,3,4};

1.8. 使用红黑树，自定义操作符

struct person{
    int age;
    
    bool operator<(const Person& other) const{
        if(age != other.age){
            return age< other.age;
        }
    }
    
    friend ostream& operator<<(ostream&& os, const person& p){
        os<<p.age<<endl;
        return os;
    }
}
map<person, int> mymap;


struct PointCompare {
    bool operator()(const Point& p1, const Point& p2) const {
        if (p1.x != p2.x) {
            return p1.x < p2.x;
        }
        return p1.y < p2.y;
    }
};
std::map<Point, std::string, PointCompare> pointMap;
// 这里不能使用out

1.9. priority_queue

// 只能使用仿函数类型
class mycomparison{
    public:
    bool operator()(const int& a,const int& b)const{
        if(a>b){
            return true;
        }else{
            return false;
        }
    }
};


priority_queue<int> q;// 大顶堆，数据大的在顶端
priority_queue<int, vector<int>, mycomparison> min_pq; //小顶堆，小数据在顶端

1.10. numeric

#include <numeric>

int sum = std::accumulate(numbers.begin(), numbers.end(), 0);// 默认求和
int product = std::accumulate(numbers.begin(), numbers.end(), 1, std::multiplies<int>());
// 默认求积

#include <algorithm>

auto min_it = min_element(number.begin(), number.end(), mycomparison);
auto max_it = max_element(number.begin(), number.end(), mycomparison);
auto minmax = minmax_element(number.begin(), number.end(),mycomparison);