STL（详细代码）

一、vector

封装了动态大小数组的顺序容器

基本函数

1. 构造与析构

1）vector();        //创建空vector

2）vector(int size);        //创建元素个数为size的vector

3）vector(int size , const T& t);        //创建元素个数为size，且值均为t的vector

4）vector(const vector&);        //复制构造函数

5）vector(begin , end);        //复制[begin , end)区间内元素到vector

6）~vector();        //删除所有元素，释放内存

//---构造与析构---
    vector<int> myV;//空vector
    vector<int> myV1(10);//元素个数为10
    vector<int> myV2(10,123);//元素个数为10，且值均为123

    vector<int>::iterator vfirst,vsecond;
    vfirst = myV.begin();
    vsecond = myV.end() - 1;//最后一个元素
    vector<int> myV3(vfirst,vsecond);//从myV中提取拷贝(begin到end的前一个)

2. 非变动性函数

1）int size() const;        //返回元素个数

2）bool empty() const;        //判断是否为空      

3）int capacity() const;        //返回空间大小

4）int max_size() const;        //返回可允许的最大元素值

5）operator  ==、!=、<、<=、>、>=

//---非变动性函数---
    printf("%lu\n",myV.size());//数组元素个数
    printf("%lu\n",myV.capacity());//数组空间大小
    if (myV > myV2)//关系判断的标准是基于strcmp
    {
        printf("myV > myV2\n");
    }
    else
        printf("myV <= myV2\n");

3. 赋值操作

1）void swap(vector& t);        //交换两个同类型的数据

2）void assign(int n , const T& t);        //设置n个值为t的元素

3）void assign(const_iterator first , const_iterator end);

        //容器中[first , end)中元素设置为当前元素

4）operator =

//---赋值操作---
    myV.swap(myV2);
    myV.assign(5,123);//设置容器中5个123

4. 元素存取

1）reference at(int pos);        //返回下标pos的元素

2）reference front();        //返回首元素

3）reference back();        //返回尾元素

//---元素存取---
    printf("%d\n",myV.at(3));//返回下标3的元素
    printf("%d\n",myV.front());//返回首元素
    printf("%d\n",myV.back());//返回尾元素

5. 迭代器相关

1）iterator begin();        //返回头指针，指向第一个元素

2）iterator end();        //返回尾指针，指向最后一个元素的下一个位置

3）reverse_iterator rbegin();        //反向迭代器，指向最后一个元素

4）reverse_iterator rend();        //反向迭代器，指向第一个元素的前一个位置

//---迭代器相关---
    vfirst = myV.begin();
    *vfirst = 11;

6. 插入删除

1）void push_back(const T& t);        //向容器尾部增加元素t

2）iterator insert(iterator vit , const T& t);        //向迭代器指向的元素前增加元素t

3）iterator insert(iterator vit , int n , const T& t);        //向迭代器指向的元素前增加n个元素t

4）iterator erase(iterator vit);        //删除迭代器指向的元素

5）iterator erase(iterator first , iterator end);        //删除[first , end]中的元素

6）void pop_back();        //删除尾部元素

7）void clear();        //清空容器中所有元素

//---插入删除---
    for (int i = 0; i < 10; i++)
    {
        myV.push_back(i+1);//尾部添加
    }
    vector<int>::iterator vit;//vector容器内嵌的迭代器
    vit = myV.begin();
    myV.insert(vit,123);//插入123
    myV.insert(vit,2,123);//插入两个123
    myV.erase(vit);//删除
    for (vit = myV.begin(); vit != myV.end(); vit++)
    {
        printf("%d\n",*vit);//输出
    }

7. 改变大小

1）void resize(int n);        //将元素个数改为n

2）void resize(int n , T elem);        //将元素个数改为n，如果size()大了，多出来的为elem

    vectorArr.resize(row);//定义行数

实现二维数组

    int row = 5;//行数
    int col = 6;//列数
    vector< vector<int> > vectorArr;
    vectorArr.resize(row);//定义行数
    for (int i = 0; i < row; i++)
    {
        vectorArr[i].resize(col);//定义列数
        for (int j = 0; j < col; j++)
        {
            vectorArr[i][j] = i*col + j + 1;//赋值
        }
    }
    for (int i = 0; i < row; i++)
    {
        for (int j = 0; j < col; j++)
        {
            printf("%d\t",vectorArr[i][j]);//输出
        }
        printf("\n");
    }

二、stack

栈是一种先进后出的数据结构，是操作受限的线性表

基本函数

1. 入栈出栈

1）push(elem);        //入栈，插入elem的一个副本

2）pop();        //出栈

2. 其他函数

1）empty();        //判断是否为空

2）size();        //返回元素个数

3）swap(s2);        //将自己与s2容器进行互换 

4）top();        //返回栈顶元素

代码示例 

    stack<int> myS;//空栈

    myS.push(1);//入栈
    myS.push(2);

    while (!myS.empty())//判空
    {
        printf("%d\n",myS.top());//输出栈顶元素
        myS.pop();//出栈
    }

三、queue

队列是一种先进先出的数据结构，也是操作受限的线性表，不提供迭代器操作

基本函数

1. 入队出队

1）push(elem);        //入队，在队尾插入elem的一个副本

2）pop();        //出队，删除队首元素

2. 其他函数

1）empty();        //判断是否为空

2）size();        //返回元素个数

3）front();        //返回队首元素

4）back();        //返回队尾元素

5）swap(q2);        //将自己与q2容器进行互换

代码示例

    queue<int> myQ1;//空队
    queue<int> myQ2;//空队

    myQ1.push(1);//入队
    myQ1.push(2);
    myQ2.push(1);
    myQ2.push(2);

    while (!myQ1.empty())//判空
    {
        printf("%d\n",myQ1.front());//输出队首元素
        printf("%d\n",myQ1.back());//输出队尾元素
        myQ1.pop();//出队
    }
    //栈和队都还有关系运算符的重载操作
    if (myQ1 > myQ2)
    {
        printf("myQ1 > myQ2\n");
    }
    else
        printf("myQ1 <= myQ2\n");

四、deque

是双向开口的连续线性空间（动态将多个连续空间通过指针数组结合在一起）

基本函数

1. 构造与析构

1）deque d;        //创建空deque

2）deque d1(d2);        //复制构造函数

3）deque d(n);        //创建一个元素个数为n的deque

4）deque d(n , elem);        //创建一个元素个数为n，元素均为elem副本的deque

5）deque d(beg , end);        //创建一个deque，以区间[beg , end)内元素作初值

6）~deque();        //删除所有元素，释放内存

2. 非变动性函数

1）front();        //返回第一个元素

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

3）begin();        //返回头指针，指向第一个元素

4）end();        //返回尾指针，指向最后一个元素的下一个位置

5）rbegin();        //反向迭代器，指向最后一个元素

6）rend();        //反向迭代器，指向第一个元素的前一个位置

3. 赋值操作

1）operator =        //将d2的所有元素赋值给d1

2）assign(n , elem);        //将n个elem副本赋值给q

3）assign(beg , end);        //将区间[beg , end)中的元素赋值给q

4）d1.swap(d2);        //将d1与d2的元素互换

5）swap(d1 , d2);        //将d1与d2的元素互换，此为全局变量

4. 插入删除

1）insert(pos , elem);        //在下标pos位置插入elem的一个副本

2）insert(pos , n , elem);        //在下标pos位置插入elem的n个副本

3）insert(pos , beg , end);        //在下标pos位置插入在区间[beg , end)中的所有元素

4）push_back(elem);        //在尾部添加elem的一个副本

5）pop_back();        //删除尾部元素

6）push_front(elem);        //在头部添加elem的一个副本

7）pop_front();        //删除头部元素

8）erase(pos);        //删除下标pos位置上的元素，返回下一个元素位置

9）erase(beg , end);        //删除[beg , end)区间内的所有元素，返回下一个元素位置

10）clear();        //清空容器中所有元素

5. 改变大小

1）resize(n);        //将元素个数改为n，如果size()大了，多出来的都以默认构造函数产生出来

2）resize(n , elem);        //将元素个数改为n，如果size()大了，多出来的为elem

代码示例

    deque<int> myD;
    for (int i = 0; i < 5; i++)
    {
        myD.push_front(i+1);//头部添加
    }
    for (int i = 0; i < 5; i++)
    {
        myD.push_back((i+1)*10);//尾部添加
    }

    deque<int>::iterator dit;//迭代器
    dit = myD.begin() + 4;
    myD.erase(dit);//删除

    for (dit = myD.begin(); dit != myD.end(); dit++)
    {
        printf("%d\n",*dit);
    }

五、list

list使用一个双向链表来管理元素 

基本函数 

1. 构造与析构

1）list a;        //创建空list

2）list a1(a2);        /复制构造函数

3）list a(n);        //创建一个元素个数为n的list

4）list a(n , elem);        //创建一个元素个数为n，元素均为elem副本的list

5）list a(beg , end);        //创建一个list，以区间[beg , end)内元素作初值

6）~list();        //删除所有元素，释放内存

2. 非变动性函数

1）size();        //返回元素个数

2）empty();        //判断是否为空

3）max_size();        //返回可允许的最大元素数量

4）operator ==、!=、<、<=、>、>=

3. 赋值函数

1）operator =        //将a2的所有元素赋值给a1

2）a.assign(n , elem);        //将n个elem副本赋值给a

3）a.assign(beg , end);        //将区间[beg , end)中的元素赋值给a

4）a1.swap(a2);        //将a1与a2的元素互换

5）swap(a1 , a2);        //将a1与a2的元素互换，此为全局变量

4. 直接取

1）a.front();        //返回第一个元素

2）a.back();        //返回最后一个元素

注意：list不支持随机存取，只有上述2个函数才能直接取元素

5. 迭代器相关

1）a.begin();        //返回头指针，指向第一个元素

2）a.end();        //返回尾指针，指向最后一个元素的下一个位置

3）a.rbegin();        //反向迭代器，指向最后一个元素

4）a.rend();        //反向迭代器，指向第一个元素的前一个位置

注意：只有运用迭代器，才能直接存取list中元素           

6. 插入删除

1）a.insert(pos , elem);        //在迭代器pos位置插入elem的一个副本，返回新元素的位置

2）a.insert(pos , n , elem);        //在迭代器pos位置插入elem的n个副本

3）a.insert(pos , beg , end);        //在迭代器pos位置插入在区间[beg , end)中的所有元素

4）a.push_back(elem);        //在尾部添加elem的一个副本

5）a.pop_back();        //删除尾部元素

6）a.push_front(elem);        //在头部添加elem的一个副本

7）a.pop_front();        //删除头部元素

8）a.erase(pos);        //删除迭代器pos位置上的元素，返回下一个元素位置

9）a.erase(beg , end);        //删除[beg , end)区间内的所有元素，返回下一个元素位置

10）a.clear();        //清空容器中所有元素

11）a.remove(val);        //删除所有值为val的元素

12）a.remove_if(op);        //删除所有“造成op结果为true”的元素

bool isBase(int val)
{
    return val%2 == 1;
}

    list<int> myL;
    for (int i = 0; i < 5; i++)
    {
        myL.push_front(i+1);//头部添加
    }
    for (int i = 0; i < 5; i++)
    {
        myL.push_back((i+1)*10);//尾部添加
    }

    myL.push_front(1);
    myL.push_front(1);
    myL.push_back(1);
    myL.push_back(1);
    myL.push_back(1);

    list<int>::iterator lit;//迭代器
    lit = myL.begin();
    for (int i = 0; i < 3; i++)
    {
        lit++;
    }
    myL.insert(lit,123);
    // myL.remove(1);
    myL.remove_if(isBase);

    for (lit = myL.begin(); lit != myL.end(); lit++)
    {
        printf("%d\n",*lit);
    }

7. 改变大小

1）a.resize(n);        //将元素个数改为n，如果size()大了，多出来的都以默认构造函数产生出来

2）a.resize(n , elem);        //将元素个数改为n，如果size()大了，多出来的为elem

8. 特殊变动性函数

1）a.unique();        //如果存在若干个相邻而数值相同的元素，删除重复元素，只留下一个

2）a.unique(op);        //如果存在若干个相邻元素，都使op()的结果为true，删除重复元素，只留下一个

3）a1.splice(pos , a2);        //将a2内的所有元素转移到a1内的pos之前

4）a1.splice(pos , a2 , a2pos);        //将a2内的a2pos所指元素转移到a1内的pos所指位置上

5）a1.splice(pos , a2 , a2beg , a2end);        //将a2内的[a2beg , a2end)区间内的所有元素转移到a2内的pos之前

6）a.sort();        //以operator< 为准则，对所有元素排序

7）a.sort(op);        //以op()为准则，对所有元素排序

8）a1.merge(a2);        //假设a1和a2容器都包含已排序元素，将a2的全部元素转移到a1，并保证合并后已排序

9）a1.merge(a2 , op);        //假设a1和a2容器都包含op()准则下的已排序元素，将a2的全部元素转移到a1，并保证合并后已排序

10）a.reverse();        //将所有元素反序

六、map

一种非严格意义上的平衡二叉树（二叉查找树）

基本函数

1. 构造与析构

1）map p;        //创建空map

2）map p1(p2);        //复制构造函数

3）map p(beg , end);        //创建一个map，以区间[beg , end)内元素作初值

4）~map();        //删除所有元素，释放内存

2. 非变动性操作

1）p.size();

2）p.empty();

3）p.max_size();

4）operator ==、!=、>、>=、<、<=

5）find(key);        //返回“键值等于key”的元素，找不到返回end()

3. 赋值操作

1）operator =        //将p2的所有元素赋值给p1

2）p1.swp(p2);        //将p1与p2的元素互换

3）swap(p1 , p2);        //将p1与p2的元素互换，此为全局变量

4. 插入删除

1）p.insert(elem);        //插入elem的一个副本

2）p.insert(pos , elem);        //在迭代器pos位置插入elem的一个副本

3）p.insert(beg , end);        //将区间[beg , end)中的所有元素插入

8）p.erase(pos);        //删除迭代器pos位置上的元素，无返回值

9）p.erase(beg , end);        //删除[beg , end)区间内的所有元素，无返回值

10）p.clear();        //清空容器中所有元素

代码示例

    map <string,int> myM;
    //第一个是key的类型，第二个是value的类型

    myM.insert(std::make_pair("zhangsan",10));
    //通过std命名空间里的函数模版来进行插入

    myM.insert(map<string,int>::value_type("lisi",20));
    //通过map里面有个结构来进行插入

    myM.insert(std::pair<string,int>("wangwu",30));
    //通过std里面的pair这个结构来进行插入

    map<string,int>::iterator mit;
    for (mit = myM.begin(); mit != myM.end(); mit++)
    {
        printf("%s-%d\n",mit->first.c_str(),mit->second);
    }

七、multimap

map容器中一个key对应一个value，multimap容器中一个key可以对应多个value 

作用：通讯录

基本函数

特殊搜寻操作

1）count(key);        //返回“键值等于key”的元素个数

2）find(key);        //返回“键值等于key”的第一个元素，找不到就返回end()

3）lower_biund(key);        //返回“键值等于key”的元素的第一个可插入位置，也就是“键值 >= key”的第一个元素位置

4）upper_bound(key);        //返回“键值等于key”的元素的最后一个可插入位置，也就是“键值 > key”的第一个元素位置

5）equal_range(key);        //返回“键值等于key”的元素的第一个可插入位置和最后一个可插入位置，也就是“键值 = key”的元素区间

代码示例 

    multimap<int,string> myP;
    myP.insert(std::make_pair(2,"zhang"));
    myP.insert(std::make_pair(2,"li"));
    myP.insert(std::make_pair(2,"wang"));
    myP.insert(std::make_pair(1,"aaa"));
    myP.insert(std::make_pair(3,"bbb"));
    //  //myP[2];没有这样的引用

    printf("%lu\n",myP.count(2));//元素个数

    multimap<int,string>::iterator pit;

    pit = myP.lower_bound(2);//返回第一个可插入位置
    printf("%d-%s\n",pit->first,pit->second.c_str());
    pit = myP.upper_bound(2);//返回最后一个可插入位置
    printf("%d-%s\n",pit->first,pit->second.c_str());
    printf("------------\n");

    auto res = myP.equal_range(2);//返回两个位置
    printf("%d-%s\n",res.first->first,res.first->second.c_str());
    printf("%d-%s\n",res.second->first,res.second->second.c_str());

    pit = myP.find(2);//返回第一个元素
    printf("%d-%s\n",pit->first,pit->second.c_str());
    printf("------------\n");

    for (pit = myP.begin(); pit != myP.end(); pit++)
    {
        printf("%d-%s\n",pit->first,pit->second.c_str());
    }

八、set

和map也很类似，也是封装了平衡二叉树，关联式容器 

作用：去重

集合操作

1）std::set_insersection();        //求两个集合的交集

2）std::set_union();        //求两个集合的并集

3）std::set_difference();        //差集

4）std::set_symmetric_difference();        //得到的结果是第一个迭代器相对于第二个的差集

九、multiset 

和set有区别的地方是，值可以出现多个。set中值是唯一，multiset值可以不是唯一

基本函数

1）count(key);        //返回“键值等于key”的元素个数

2）find(key);        //返回“键值等于key”的第一个元素，找不到就返回end()

3）lower_biund(key);        //返回“键值等于key”的元素的第一个可插入位置，也就是“键值 >= key”的第一个元素位置

4）upper_bound(key);        //返回“键值等于key”的元素的最后一个可插入位置，也就是“键值 > key”的第一个元素位置

5）equal_range(key);        //返回“键值等于key”的元素的第一个可插入位置和最后一个可插入位置，也就是“键值 = key”的元素区间

代码示例

#include <set>
using std::set;
#include <algorithm>
#include <iterator>
using std::insert_iterator;

    set<int> s1,s2;

    for (int i = 0; i < 3; i++)
    {
        s1.insert(i+1);
        s2.insert(i+1);
    }
    s1.insert(123);
    s1.insert(456);
    s2.insert(20);
    s2.insert(30);

    set<int>::iterator sit;
    sit = s1.find(3);
    printf("%d\n",*sit);
    printf("------------\n");

    set<int> out[5];
    //---交集---
    std::set_intersection(s1.begin(),
                            s1.end(),
                            s2.begin(),
                            s2.end(),
        insert_iterator< set<int> >(out[0],out[0].begin()));
    printf("交集：\n");
    for (sit = out[0].begin(); sit != out[0].end(); sit++)
    {
        printf("%d\n",*sit);
    }
    printf("------------\n");
    //---并集---
    std::set_union(s1.begin(),
                            s1.end(),
                            s2.begin(),
                            s2.end(),
        insert_iterator< set<int> >(out[1],out[1].begin()));
    printf("并集：\n");
    for (sit = out[1].begin(); sit != out[1].end(); sit++)
    {
        printf("%d\n",*sit);
    }
    printf("------------\n");
    //---差集1---
    std::set_difference(s1.begin(),
                            s1.end(),
                            s2.begin(),
                            s2.end(),
        insert_iterator< set<int> >(out[2],out[2].begin()));
    printf("差集1:\n");
    for (sit = out[2].begin(); sit != out[2].end(); sit++)
    {
        printf("%d\n",*sit);
    }
    printf("------------\n");
    //---差集2---
    std::set_difference(s2.begin(),
                            s2.end(),
                            s1.begin(),
                            s1.end(),
        insert_iterator< set<int> >(out[3],out[3].begin()));
    printf("差集2:\n");
    for (sit = out[3].begin(); sit != out[3].end(); sit++)
    {
        printf("%d\n",*sit);
    }
    printf("------------\n");
    //---差集合并---
    std::set_symmetric_difference(s1.begin(),
                            s1.end(),
                            s2.begin(),
                            s2.end(),
        insert_iterator< set<int> >(out[4],out[4].begin()));
    printf("差集合并:\n");
    for (sit = out[4].begin(); sit != out[4].end(); sit++)
    {
        printf("%d\n",*sit);
    }
    printf("------------\n");

    for (sit = s1.begin(); sit != s1.end(); sit++)
    {
        printf("%d\n",*sit);
    }
    printf("------------\n");
    for (sit = s2.begin(); sit != s2.end(); sit++)
    {
        printf("%d\n",*sit);
    }