容器 数据结构 构造函数 增 删 取 判断
    vector 单端数组 //无参构造;
    vector v1;
    //区间拷贝构造函数;
    vector v2(v1.begin(), v1.end());
    //拷贝构造函数
    vector v3(v2);
    //直接赋值操作
    vector v1;
    vector v2;
    v2 = v1;    		 push_back(t);

    //迭代器指向位置前插入元素100 vector v1;
    v1.insert(v1.begin(), 100);

    //迭代器指向位置前插入2个元素1000 v1.insert(v1.begin(), 2, 1000);
    		 pop_back();
    //删除最后一个数据

    //删除v1.begin()处的数据 v1.erase(v1.begin());

    //删除元素 v1.erase(v1.begin(),v1.begin()+2);

    //清空
    v1.clear();    		 []或者at方法 vector v1;
    //判断容器是否为空 v1.empty();
    //容器的容量
    v1.capacity();
    //容器元素个数
    v1.size();
    //重新指定容器大小 v1.resize(2);
    deque 双端数组 //无参构造函数
    deque d1;
    //区间拷贝构造函数;
    deque d2(d1.begin(), d1.end());
    //拷贝构造函数
    deque d3(d2);

    //直接赋值操作
    deque d1;
    //无参构造
    dequed2;
    d2 = d1;    		 //在尾部添加一个数据
    push_back(t);

    //在头部插入一个数据
    push_front(t);

    //删除容器最后一个数据
    pop_back();

    //删除容器第一个数据
    pop_front();

    //在前位置插入一个1000
    deque d1
    d1.insert(d1.begin(),1000);    		 //删除区间的数据。 d1.erase(d1.begin(),d1.end());
    //删除位置的数据，返回下一个数据的位置。
    d1.erase(d1.begin());    		 []或者at方法 deque d1;
    //判断容器是否为空
    d1.empty();
    //容器元素个数
    d1.size();
    //重新指定容器大小
    d1.resize(2);
    stack 栈 //无参构造函数
    stack s1;
    //拷贝构造函数
    stack s2(s1);

    //直接赋值操作，无拷贝赋值操作
    stack s1;
    stack s2;
    s2=s1;    		 //栈顶添加元素
    push(t);

    //从栈顶移除第一个元素
    pop();

    //返回栈顶元素
    top();    		 无 //判断s1是否为空
    stack s1;
    s1.empty();
    //判断s1的元素个数
    s1.size();
    queue 队列 //无参构造函数
    queue q1;
    //拷贝构造函数
    queue q2(q1);

    //直接赋值操作
    queue q1;
    queue q2;
    q2 = q1;    		 //往队尾添加元素
    push(t);

    //从队头移除第一个元素
    pop();

    /返回最后一个元素
    back();

    /返回第一个元素
    front();    		 无 //判断是否为空
    queue q1;
    q1.empty();
    //判断元素个数
    q1.size();
    list 链表 //无参构造
    list l1;
    //区间拷贝构造函数
    list l2(l1.begin(),l1.end());
    //拷贝构造函数
    list l3(l2);

    //直接赋值操作
    list l1;
    //无参构造
    list l2;
    l2 = l1;

    //容器反转
    l1.reverse();

    //容器从小到大排序
    l1.sort();

    //容器从大到小排序
    bool myCompare(int v1,int v2){ return v1>v2;
    }
    l1.sort(myCompare);    		 //插入t数据
    push_back(t);

    //删除最后一个数据
    pop_back();

    //插入
    list::iterator it = L.begin();
    L.insert(++it, 1000);    		 list L;
    //头删
    L.pop_front();

    //删除
    it = L.begin();
    L.erase(++it);

    //删除容器中所有的1000 L.remove(10000);

    //清空
    L.clear();    		 通过遍历获取 list L1;
    //判断容器是否为空
    L1.empty()；
    //判断元素个数
    L1.size();
    //重新指定大小
    L1.resize(10);
    set 二叉树

    自动排序而且去除重复元素    		 //无参构造
    set s1;
    //拷贝构造函数
    sets2(s1);

    set s1;
    sets3;
    s3 = s1;

    //容器中元素3的个数
    int num=s1.cout(3);

    //查找容器中是否有元素30
    set::iterator pos = s1.find(30);
    if (pos != s1.end()) {
    cout << “找到了元素 ： “ << *pos << endl;
    }
    else {
    cout << “未找到元素” << endl;
    }    		 //插入t数据
    insert(t);    		 //删除t元素
    erase(t);    		 通过遍历获取 set s1;
    //容器是否为空
    s1.empty();
    //容器元素大小
    s1.size();
    //清空
    s1.clear();
    map 二叉树

    所有元素都是pair型(键值对)
    不允许用重复的key元素    		 //默认构造函数
    map m;
    //拷贝构造
    map m2(m);

    map m1;
    map m3;
    m3 = m1;

    //统计
    int num = m.count(3);

    //查找
    map::iterator pos = m.find(3);
    if (pos != m.end()) {
    cout << “找到了元素 key = “ << (pos).first << “ value = “ << (pos).second << endl;
    }else{
    cout << “未找到元素” << endl;
    }    		 //插入键值对1:10
    insert(pair(1, 10));

    map m;
    //第一种插入方式
    m.insert(pair(1, 10));
    //第二种插入方式
    m.insert(make_pair(2, 20));
    //第三种插入方式
    m.insert(map::value_type(3, 30)); //第四种插入方式，不建议使用
    m[4] = 40;

    		 //删除第一个元素
    m.erase(m.begin());

    //删除容器中的3
    m.erase(3);    		 通过遍历获取 map m;
    //容器是否为空
    map.empty();
    //容器元素多少
    m.size();
    //清空
    m.clear();