#include <vector>
#include <stack>
#include <queue>
#include <list>
#include <set>

1. vector 容器

(1). 容量

向量大小： vec.size();
向量真实大小： vec.capacity();
向量判空： vec.empty();

(2). 修改

末尾添加元素： vec.push_back();
末尾删除元素： vec.pop_back();
任意位置插入元素： vec.insert();
任意位置删除元素： vec.erase();
清空向量元素： vec.clear();

(3)迭代器

开始指针：vec.begin();
末尾指针：vec.end(); //指向最后一个元素的下一个位置
指向常量的末尾指针： vec.cend();

(4)元素的访问

下标访问： vec[1]; //并不会检查是否越界
at方法访问： vec.at(1); //以上两者的区别就是at会检查是否越界，是则抛出out of range异常
访问第一个元素： vec.front();
访问最后一个元素： vec.back();

int main(){ // vector 数组
    // vector
    // 1. vector<int> v;

    // 2. vector<int> v(10);

    // 3. vector<int> v(10,0);

    vector<int> v;

    // 插入数据
    // v.begin(); // 迭代器的开始位置
    v.insert(v.begin(),12);
    v.insert(v.begin(),22);
    v.insert(v.begin(),32);

    v.insert(v.end(),42);

    // 引用当左值当右值（修改）
    v.front() = 33;
    v.back() = 44;

    v.push_back(55);

    // 移除最后的元素，并没有返回值
    // v.pop_back();
    // 通过迭代器位置进行移除
    // v.erase(v.begin());

    // 获取数据 for 循环
    for(int i = 0; i < v.size(); i++){
        cout << v[i] << "\t"; // 越界程序宕机,clion 和 AS中不一定出错
    }
    cout << endl;
    //
    for(int i = 0; i < v.size(); i++){
        cout << v.at(i) << "\t"; // 越界抛异常 out_of_range
    }
    cout << endl;

    // 通过迭代器
    for(vector<int>::iterator it = v.begin(); it != v.end(); it++){
        cout << *it << "\t"; // 越界抛异常 out_of_range
    }
    cout << endl;
}

2. stack 容器（先进后出）

不能通过角标或迭代器去循环值

压栈：s.push(12);
获取顶部元素：s.top();
弹栈顶部元素：s.pop();
判空： s.empty();

3. queue 容器（先进先出）

添加元素：s.push(12);
访问第一个元素： q.front();
访问最后一个元素： q.back();
弹出第一个元素：q.pop();

4. 优先级队列 priority_queue

// int 存放的数据 vector<int> 数据类型（数组） greater 从大到小 less 从小到大
priority_queue<int,vector<int>,greater<int>> pq;
pq.push(12);
pq.push(44);
pq.push(32);
pq.push(10);

// 最大值 
cout << pq.top() << endl;

5. list 容器(链表，双向链表)

不能通过角标去访问

插入：

开头插入：l.push_front(11);
末尾插入：l.push_back(22);
指定的iterator位置插入：l.insert(l.begin(),10);

修改：

修改最后一个元素：l.back() = 33;
修改最开头的元素：l.front() = 44;

移除：

移除指定位置上元素：l.erase(l.begin());
移除开头元素：l.pop_front();
移除末尾元素：l.pop_back();

循环：

// 循环
for (list<int>::iterator it = l.begin(); it != l.end(); it++)
{
	cout << *it << endl;
}

6. set 容器

set 容器（红黑树结构），会对你存入的数据进行排序，但是不允许元素相同

set<int, greater<int>> s;：排序从大到小
set<int, less<int>> s;：排序从大到小
pair<set<int,greater<int>>::iterator ,bool> res = s.insert(5);：插入

// set<int, less<int>> s; // 从小到大排序，默认就是 less
   set<int, greater<int>> s; // 从大到小

   // 添加参数， 不需要用迭代器，也不需要指定位置
   s.insert(3);
   s.insert(5);
   s.insert(4);

   // 重复的插入，并不会报错，返回两个值 插入迭代器的位置，是否插入功
   pair<set<int,greater<int>>::iterator ,bool> res = s.insert(5);
   // res.first;// 获取第一个参数
   bool insert_succeed = res.second;
   if(insert_succeed){
       cout << "插入成功" << endl;
   }else{
       cout << "插入失败" << endl;
   }

    int count = s.count(5);
   // s.find();

   for(set<int> :: iterator it = s.begin(); it != s.end(); it ++){
       cout << *it << endl;
   }

7.函数谓词和函数对象

函数谓词：按照特定的规则所表写的函数谓词

函数对象：有函数重载了（）运算符

class Student{
public:
    string name;
    int grade;
public:
    Student(string name,int grade):name(name),grade(grade){}
};

// 谓词（函数谓词）：按照特定的规则所表写的函数谓词
bool compare(const Student& _Left,const Student& _Right){
    return _Left.grade > _Right.grade;
}

// 函数对象 仿函数
struct comparefuction{
    // 函数重载了（）运算符，函数对象，仿函数
    bool operator()(const Student& _Left,const Student& _Right){
        return _Left.grade > _Right.grade; // 从大到小
    }
};

// 基本数据类型，对象数据类型
int main(){
    set<Student,comparefuction> s;

    Student s1("eastrise",2);
    Student s2("eastrise",9);
    Student s3("eastrise",5);

    s.insert(s1);
    s.insert(s2);
    s.insert(s3);

    for(set<Student>::iterator it = s.begin(); it!=s.end(); it ++){
        cout << it->name << "," << it->grade << endl;
    }
}

8. multiset容器

multiset容器 , 允许重复，用法和 set 一样

// set<int,less<int>>;// 从小到大排序，默认就是 less
multiset<int,greater<int>> ms;

// 添加参数， 不需要用迭代器，也不需要指定位置
ms.insert(3);
ms.insert(5);
ms.insert(4);
ms.insert(4);
ms.insert(3);

for(set<int>::iterator it = ms.begin(); it != ms.end(); it++){
    cout << *it << endl;
}